{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning, module=\"torch.nn.functional\")\n",
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "from fastai.vision import *\n",
    "import torch\n",
    "from torchsummary import summary\n",
    "torch.cuda.set_device(1)\n",
    "torch.manual_seed(0)\n",
    "torch.cuda.manual_seed(0)\n",
    "\n",
    "from models.custom_resnet import *\n",
    "from utils import _get_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(path, train = 'train', valid = val, bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    savename = '../saved_models/' + dataset + '/' + model_name + '_no_teacher/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('no_teacher : ', _get_accuracy(data.valid_dl, net))\n",
    "    noteacher_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    return noteacher_acc, stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.918, 0.974)\n",
      "(0.912, 0.988)\n",
      "(0.914, 0.988)\n",
      "(0.916, 0.988)\n",
      "(0.906, 0.99)\n"
     ]
    }
   ],
   "source": [
    "print(check('resnet10', 'imagenette'))\n",
    "print(check('resnet14', 'imagenette'))\n",
    "print(check('resnet18', 'imagenette'))\n",
    "print(check('resnet20', 'imagenette'))\n",
    "print(check('resnet26', 'imagenette'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.802, 0.906)\n",
      "(0.786, 0.928)\n",
      "(0.792, 0.924)\n",
      "(0.798, 0.92)\n",
      "(0.802, 0.934)\n"
     ]
    }
   ],
   "source": [
    "print(check('resnet10', 'imagewoof'))\n",
    "print(check('resnet14', 'imagewoof'))\n",
    "print(check('resnet18', 'imagewoof'))\n",
    "print(check('resnet20', 'imagewoof'))\n",
    "print(check('resnet26', 'imagewoof'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.802 , 0.786 , 0.792 , 0.798 , 0.802\n",
      "0.906 , 0.928 , 0.924 , 0.92 , 0.934\n"
     ]
    }
   ],
   "source": [
    "a1, a2 = check('resnet10', 'imagewoof')\n",
    "b1, b2 = check('resnet14', 'imagewoof')\n",
    "c1, c2 = check('resnet18', 'imagewoof')\n",
    "d1, d2 = check('resnet20', 'imagewoof')\n",
    "e1, e2 = check('resnet26', 'imagewoof')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)\n",
    "print(a2, ',', b2, ',', c2, ',', d2, ',', e2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.7788, 0.8475)\n",
      "(0.775, 0.8497)\n",
      "(0.7735, 0.8599)\n",
      "(0.7808, 0.8646)\n",
      "(0.783, 0.8662)\n"
     ]
    }
   ],
   "source": [
    "print(check('resnet10', 'cifar10'))\n",
    "print(check('resnet14', 'cifar10'))\n",
    "print(check('resnet18', 'cifar10'))\n",
    "print(check('resnet20', 'cifar10'))\n",
    "print(check('resnet26', 'cifar10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7788 , 0.775 , 0.7735 , 0.7808 , 0.783\n",
      "0.8475 , 0.8497 , 0.8599 , 0.8646 , 0.8662\n"
     ]
    }
   ],
   "source": [
    "a1, a2 = check('resnet10', 'cifar10')\n",
    "b1, b2 = check('resnet14', 'cifar10')\n",
    "c1, c2 = check('resnet18', 'cifar10')\n",
    "d1, d2 = check('resnet20', 'cifar10')\n",
    "e1, e2 = check('resnet26', 'cifar10')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)\n",
    "print(a2, ',', b2, ',', c2, ',', d2, ',', e2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_ld(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    new_path = path/'new'\n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(new_path, train = 'train', valid = 'val', test = 'test', bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/less_data/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    savename = '../saved_models/' + dataset + '/less_data/' + model_name + '_no_teacher/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('no_teacher : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_noteacher_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    return ld_noteacher_acc, ld_stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.848, 0.954)\n",
      "(0.85, 0.95)\n",
      "(0.854, 0.956)\n",
      "(0.85, 0.958)\n",
      "(0.832, 0.96)\n"
     ]
    }
   ],
   "source": [
    "print(check_ld('resnet10', 'imagenette'))\n",
    "print(check_ld('resnet14', 'imagenette'))\n",
    "print(check_ld('resnet18', 'imagenette'))\n",
    "print(check_ld('resnet20', 'imagenette'))\n",
    "print(check_ld('resnet26', 'imagenette'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.848 , 0.85 , 0.854 , 0.85 , 0.832\n",
      "0.954 , 0.95 , 0.956 , 0.958 , 0.96\n"
     ]
    }
   ],
   "source": [
    "a1, a2 = check_ld('resnet10', 'imagenette')\n",
    "b1, b2 = check_ld('resnet14', 'imagenette')\n",
    "c1, c2 = check_ld('resnet18', 'imagenette')\n",
    "d1, d2 = check_ld('resnet20', 'imagenette')\n",
    "e1, e2 = check_ld('resnet26', 'imagenette')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)\n",
    "print(a2, ',', b2, ',', c2, ',', d2, ',', e2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.632, 0.858)\n",
      "(0.616, 0.89)\n",
      "(0.602, 0.89)\n",
      "(0.6, 0.876)\n",
      "(0.588, 0.898)\n"
     ]
    }
   ],
   "source": [
    "print(check_ld('resnet10', 'imagewoof'))\n",
    "print(check_ld('resnet14', 'imagewoof'))\n",
    "print(check_ld('resnet18', 'imagewoof'))\n",
    "print(check_ld('resnet20', 'imagewoof'))\n",
    "print(check_ld('resnet26', 'imagewoof'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.632 , 0.616 , 0.602 , 0.6 , 0.588\n",
      "0.858 , 0.89 , 0.89 , 0.876 , 0.898\n"
     ]
    }
   ],
   "source": [
    "a1, a2 = check_ld('resnet10', 'imagewoof')\n",
    "b1, b2 = check_ld('resnet14', 'imagewoof')\n",
    "c1, c2 = check_ld('resnet18', 'imagewoof')\n",
    "d1, d2 = check_ld('resnet20', 'imagewoof')\n",
    "e1, e2 = check_ld('resnet26', 'imagewoof')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)\n",
    "print(a2, ',', b2, ',', c2, ',', d2, ',', e2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0.6635, 0.8159)\n",
      "(0.6489, 0.8255)\n",
      "(0.6466, 0.8328)\n",
      "(0.652, 0.8324)\n",
      "(0.6409, 0.8364)\n"
     ]
    }
   ],
   "source": [
    "print(check_ld('resnet10', 'cifar10'))\n",
    "print(check_ld('resnet14', 'cifar10'))\n",
    "print(check_ld('resnet18', 'cifar10'))\n",
    "print(check_ld('resnet20', 'cifar10'))\n",
    "print(check_ld('resnet26', 'cifar10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6635 , 0.6489 , 0.6466 , 0.6519 , 0.6409\n",
      "0.8159 , 0.8255 , 0.8328 , 0.8324 , 0.8364\n"
     ]
    }
   ],
   "source": [
    "a1, a2 = check_ld('resnet10', 'cifar10')\n",
    "b1, b2 = check_ld('resnet14', 'cifar10')\n",
    "c1, c2 = check_ld('resnet18', 'cifar10')\n",
    "d1, d2 = check_ld('resnet20', 'cifar10')\n",
    "e1, e2 = check_ld('resnet26', 'cifar10')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)\n",
    "print(a2, ',', b2, ',', c2, ',', d2, ',', e2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_ld8(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    new_path = path/'new8'\n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(new_path, train = 'train', valid = 'val', test = 'test', bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/less_data8/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    savename = '../saved_models/' + dataset + '/less_data8/' + model_name + '_no_teacher/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('no_teacher : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_noteacher_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    return ld_noteacher_acc, ld_stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_simultaneous(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(path, train = 'train', valid = val, bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/simultaneous/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "        \n",
    "    return stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_trad_kd(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(path, train = 'train', valid = val, bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/trad_kd/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "        \n",
    "    return stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_trad_kd_ld(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    new_path = path/'new8'\n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(new_path, train = 'train', valid = 'val', test = 'test', bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/trad_kd_ld/' + model_name + '_classifier/model1.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    return ld_stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.922\n",
      "0.932\n",
      "0.924\n",
      "0.924\n",
      "0.918\n"
     ]
    }
   ],
   "source": [
    "print(check_simultaneous('resnet10', 'imagenette'))\n",
    "print(check_simultaneous('resnet14', 'imagenette'))\n",
    "print(check_simultaneous('resnet18', 'imagenette'))\n",
    "print(check_simultaneous('resnet20', 'imagenette'))\n",
    "print(check_simultaneous('resnet26', 'imagenette'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.912\n",
      "0.9\n",
      "0.902\n",
      "0.912\n",
      "0.9\n"
     ]
    }
   ],
   "source": [
    "print(check_trad_kd('resnet10', 'imagenette'))\n",
    "print(check_trad_kd('resnet14', 'imagenette'))\n",
    "print(check_trad_kd('resnet18', 'imagenette'))\n",
    "print(check_trad_kd('resnet20', 'imagenette'))\n",
    "print(check_trad_kd('resnet26', 'imagenette'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.772\n",
      "0.784\n",
      "0.794\n",
      "0.788\n",
      "0.778\n"
     ]
    }
   ],
   "source": [
    "print(check_trad_kd('resnet10', 'imagewoof'))\n",
    "print(check_trad_kd('resnet14', 'imagewoof'))\n",
    "print(check_trad_kd('resnet18', 'imagewoof'))\n",
    "print(check_trad_kd('resnet20', 'imagewoof'))\n",
    "print(check_trad_kd('resnet26', 'imagewoof'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7622\n",
      "0.7708\n",
      "0.7738\n",
      "0.7722\n",
      "0.7759\n"
     ]
    }
   ],
   "source": [
    "print(check_trad_kd('resnet10', 'cifar10'))\n",
    "print(check_trad_kd('resnet14', 'cifar10'))\n",
    "print(check_trad_kd('resnet18', 'cifar10'))\n",
    "print(check_trad_kd('resnet20', 'cifar10'))\n",
    "print(check_trad_kd('resnet26', 'cifar10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.79\n",
      "0.8\n",
      "0.792\n",
      "0.792\n",
      "0.774\n"
     ]
    }
   ],
   "source": [
    "print(check_trad_kd_ld('resnet10', 'imagenette'))\n",
    "print(check_trad_kd_ld('resnet14', 'imagenette'))\n",
    "print(check_trad_kd_ld('resnet18', 'imagenette'))\n",
    "print(check_trad_kd_ld('resnet20', 'imagenette'))\n",
    "print(check_trad_kd_ld('resnet26', 'imagenette'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.496\n",
      "0.512\n",
      "0.496\n",
      "0.49\n",
      "0.484\n"
     ]
    }
   ],
   "source": [
    "print(check_trad_kd_ld('resnet10', 'imagewoof'))\n",
    "print(check_trad_kd_ld('resnet14', 'imagewoof'))\n",
    "print(check_trad_kd_ld('resnet18', 'imagewoof'))\n",
    "print(check_trad_kd_ld('resnet20', 'imagewoof'))\n",
    "print(check_trad_kd_ld('resnet26', 'imagewoof'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5611\n",
      "0.5606\n",
      "0.5639\n",
      "0.5683\n",
      "0.5538\n"
     ]
    }
   ],
   "source": [
    "print(check_trad_kd_ld('resnet10', 'cifar10'))\n",
    "print(check_trad_kd_ld('resnet14', 'cifar10'))\n",
    "print(check_trad_kd_ld('resnet18', 'cifar10'))\n",
    "print(check_trad_kd_ld('resnet20', 'cifar10'))\n",
    "print(check_trad_kd_ld('resnet26', 'cifar10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.922 , 0.932 , 0.924 , 0.924 , 0.918\n"
     ]
    }
   ],
   "source": [
    "a1 = check_simultaneous('resnet10', 'imagenette')\n",
    "b1 = check_simultaneous('resnet14', 'imagenette')\n",
    "c1 = check_simultaneous('resnet18', 'imagenette')\n",
    "d1 = check_simultaneous('resnet20', 'imagenette')\n",
    "e1 = check_simultaneous('resnet26', 'imagenette')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.798\n",
      "0.796\n",
      "0.81\n",
      "0.814\n",
      "0.842\n"
     ]
    }
   ],
   "source": [
    "print(check_simultaneous('resnet10', 'imagewoof'))\n",
    "print(check_simultaneous('resnet14', 'imagewoof'))\n",
    "print(check_simultaneous('resnet18', 'imagewoof'))\n",
    "print(check_simultaneous('resnet20', 'imagewoof'))\n",
    "print(check_simultaneous('resnet26', 'imagewoof'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.798 , 0.796 , 0.81 , 0.814 , 0.842\n"
     ]
    }
   ],
   "source": [
    "a1 = check_simultaneous('resnet10', 'imagewoof')\n",
    "b1 = check_simultaneous('resnet14', 'imagewoof')\n",
    "c1 = check_simultaneous('resnet18', 'imagewoof')\n",
    "d1 = check_simultaneous('resnet20', 'imagewoof')\n",
    "e1 = check_simultaneous('resnet26', 'imagewoof')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7732\n",
      "0.7598\n",
      "0.7647\n",
      "0.7679\n",
      "0.7694\n"
     ]
    }
   ],
   "source": [
    "print(check_simultaneous('resnet10', 'cifar10'))\n",
    "print(check_simultaneous('resnet14', 'cifar10'))\n",
    "print(check_simultaneous('resnet18', 'cifar10'))\n",
    "print(check_simultaneous('resnet20', 'cifar10'))\n",
    "print(check_simultaneous('resnet26', 'cifar10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7732 , 0.7598 , 0.7647 , 0.7679 , 0.7694\n"
     ]
    }
   ],
   "source": [
    "a1 = check_simultaneous('resnet10', 'cifar10')\n",
    "b1 = check_simultaneous('resnet14', 'cifar10')\n",
    "c1 = check_simultaneous('resnet18', 'cifar10')\n",
    "d1 = check_simultaneous('resnet20', 'cifar10')\n",
    "e1 = check_simultaneous('resnet26', 'cifar10')\n",
    "print(a1, ',', b1, ',', c1, ',', d1, ',', e1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_teacher(model_name, dataset) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(path, train = 'train', valid = val, bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "\n",
    "    if model_name == 'resnet34' :\n",
    "        learn = cnn_learner(data, models.resnet34, metrics = accuracy)\n",
    "        learn = learn.load('resnet34_' + load_name + '_bs64')\n",
    "        learn.freeze()\n",
    "        net = learn.model\n",
    "    \n",
    "    net = net.cuda()\n",
    "    return(_get_accuracy(data.valid_dl, net))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.992\n",
      "0.914\n",
      "0.8751\n"
     ]
    }
   ],
   "source": [
    "print(check_teacher('resnet34', 'imagenette'))\n",
    "print(check_teacher('resnet34', 'imagewoof'))\n",
    "print(check_teacher('resnet34', 'cifar10'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1280x880 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABEcAAAMQCAYAAADFCgtPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXyU5b3///c9S5ZJyAIkYRchgAWtaFGxVASporVCrVhba0XFpS7H5Zye1rbfAo1a9Xhqta2K8iuKeupROa1aa1srxa1VrFCxWgkE2SGQQFayzHb9/khmmMlMSCZMkpncr+fjwSOTe+77nmsyyU3mnetzfSxjjBEAAAAAAIBNOfp7AAAAAAAAAP2JcAQAAAAAANga4QgAAAAAALA1whEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAgQQ899JCmTJkij8cjy7L0wAMP9PeQAADAUSAcAQAgxViWJcuy+nsY6MRzzz2nm266SZmZmbrlllu0ZMkSTZ8+vdvHNzU1qaCgQJZl6dJLL+3FkQIAgO5y9fcAAAAA0slLL70kSXr55Zc1YsSIhI9/9tlnVVdXJ8uy9Jvf/EYHDhzQkCFDkj1MAACQAGaOAAAAJGDPnj2S1KNgRJIee+wxOZ1Offe731Vra6uefPLJZA4PAAD0AOEIAABpYNu2bbIsS1dccYW2bNmiBQsWaMiQIRo0aJDOOeccffTRR5Kkffv2adGiRRo+fLiysrJ0yimn6PXXX4853549e1RWVqYZM2Zo2LBhysjI0IgRI/SNb3xDH3/8cdwxGGP04IMPavLkycrKytLIkSN10003qa6uTmPHjtXYsWPjHvfMM89o9uzZKiwsVFZWlj7zmc/ozjvvVGtra9R+I0aM0KhRo2KOHzlypCzL0h133BG1/ZVXXpFlWVq8eHHMc7vhhhs0duxYZWRkqKioSBdeeKH+/ve/xx1fS0uL7r77bp1wwgnyeDzKy8vTGWecof/93/+N2m/p0qWyLEtr1qyRdLj8KZESqI8++kjvvvuuzjnnHH3nO9+R2+3W8uXLj3jMxo0bddVVV2ns2LHKzMxUcXGxzjjjDD3yyCM92jfyeymeWbNmxTyn119/XZZlaenSpXr33Xd13nnnqbCwUJZladu2bZKkNWvW6Nprr9XkyZOVl5en7OxsTZkyRUuWLFFzc3PcxwoEAlq2bJlmzJih/Px8ZWdnq7S0VFdffbU2b94sSbr99ttlWVanIdK6detkWZYuuOCCI34dAQA4EsIRAADSyLZt23Taaadp3759uuKKK3TOOefotdde06xZs1ReXq7p06dr/fr1uuSSS3TJJZdow4YNOvfcc7Vjx46o87z55pu65557VFBQoIsuuki33nqrTjvtNK1atUqnnnqqPvjgg5jHvvHGG3Xrrbeqrq5O1157rb7xjW/o1Vdf1dlnny2fzxd3vIsWLdKll16qLVu26KKLLtKNN96owYMH60c/+pHOPffcqOPOOuss7d69W+Xl5eFtGzduDM/UWL16ddS5//KXv0iS5syZE9726aefatq0aXrkkUdUWlqq//iP/9DcuXP1yiuvaMaMGXrxxRejzuH1enXOOefoBz/4gYLBoG688UZ961vfUnl5ub7xjW/oe9/7XnjfWbNmacmSJTrmmGMkSUuWLAn/667HHntMknTFFVdo6NCh+vKXv6xPPvlEb7/9dtz9f//73+vkk0/WypUrNWXKFP37v/+7vvrVr8rv9+u//uu/erxvT/3tb3/TzJkz5fV6tWjRIn3rW99SRkaGJOnee+/Vq6++qqlTp+q6667TokWLlJGRobKyMs2dO1d+vz/qXF6vV+eee66uv/567dy5U9/85jd1880363Of+5x++9vf6q9//ask6dvf/rYcDoceffTRuGNatmyZJOm6665LynMEANiUAQAAKUWS6fhf9NatW8Pb77zzzqj7ysrKjCSTn59vrrvuOhMIBML3/c///I+RZG699daoY/bt22fq6+tjHnvdunXG4/GYuXPnRm1/8803jSQzceJEU1NTE97e2tpqzjjjDCPJHHPMMVHHPP7440aSWbBggWlubo66b8mSJUaS+dnPfhbe9qtf/cpIMg899FB42y9/+UsjyZx99tkmIyPDHDp0KHzf1KlTTXZ2tmltbQ1vO/vss40kc88990Q93ltvvWUcDocpLCyMet533XWXkWS+/OUvG5/PF95eWVlpRo8ebSSZt956K+pcZ555Zszr0x3Nzc2msLDQFBQUmJaWFmOMMS+++KKRZC6//PKY/auqqkxeXp5xu93mjTfeiLl/x44dPdo39L20cOHCuOOM9/zWrFkT/v5btmxZ3OO2bNligsFgzPbvf//7RpJ55pln4m6/4IILwl+PkJaWFrN///7w5+eff76RZP75z39G7VdfX29ycnLM6NGjjd/vjzsuAAC6g3AEAIAUc6RwZOzYsTFvArdv324kGY/HExN4+P1+43a7zaxZs7r9+F/+8pdNZmam8Xq94W2LFi0ykszKlStj9n/77bfjhiNTp041brc7KkyJHNeQIUPMtGnTwtu2bdtmJJmvfvWr4W0XXnihGTFiRDhE+NOf/mSMMaa6utpYlmXOPvvs8L47d+4MjyMy6Ai59NJLY57D+PHjjWVZpry8PGb/xx57zEgyV155ZdT2noYjK1euNJLMt7/97fA2n89nSkpKTHZ2dszX6b//+7+NJHPzzTd3ee5E9j2acOTEE0/s8vwdVVdXx3wd/X6/yc/PN9nZ2Wb37t1dnuP3v/+9kWT+7d/+LWr7ww8/bCSZsrKyhMcFAEAkymoAAEgjU6dOldPpjNoWWhh04sSJGjRoUNR9TqdTxcXF2rVrV8y5fv/73+uCCy7Q8OHD5Xa7w+tnvPzyy2ptbVV1dXV433/84x+SpC984Qsx55k+fbpcrugGeE1NTdqwYYMKCgr0wAMPaOnSpVH/7rjjDmVmZmrjxo3hY4455hiNGzdOr7/+uoLBoILBoN544w3NmTNHZ555ppxOZ7i0Zs2aNTLG6KyzzooZ4xlnnBEzHkn64he/KElav369JKmhoUFbtmzRyJEjNXHixC73P1qhtUUi1/pwuVz65je/qebmZj399NNR+7/77ruSpPPOO6/Lcyey79E47bTTOr3v0KFD+slPfqJTTjlF+fn5cjgcsixLQ4cOlSTt3r07vO/GjRtVV1enz372s91a2Pbcc8/Vscceq6eeeipq/ZJHH31ULpdLixYtOopnBQAArXwBAEgr+fn5MdtCQUC8+0L3d1wT5Oc//7luueUWFRYW6uyzz9aYMWPk8XhkWZZeeOEFbdiwIWrB1Lq6OklSSUlJzPmdTmdMK9qamhoZY1RVVaUf//jH3X5+c+bM0fLly/XBBx/IGKODBw9qzpw5ys/P17Rp08LhSOhj5HojoTEOGzYs7rmHDx8etV+i+x+N0Loixx13XEzAcOWVV+r+++/X8uXLddNNN4W319bWSmpbkLYriex7NDr7Wvl8Pp111ll67733dPzxx+uSSy5RUVGR3G63JOnHP/5x1PdTouN1OBy67rrrdPvtt+u5557TwoULtXbtWm3YsEEXXnhhjzsHAQAQQjgCAIDN+P1+LVmyRMOGDdP69evDIUDIO++8E3NMXl6epLZuOOPGjYu6LxAI6MCBA1FvdENBzUknnZTQzIuzzjpLy5cv1+rVq2WMCW+T2oKQe+65RwcPHtTq1auVn5+vk08+OeYxKysr45577969Ufsluv/RCC3EunHjxk6723z44Ydau3ZtODwpKCiQ1Dbj4oQTTjji+RPZ1+FomzjccYHUkFBwEU9nY3/xxRf13nvvaeHChXriiSei7tu7d29MQBY53u5atGiRlixZokcffVQLFy4ML9DKQqwAgGSgrAYAAJuprq5WbW2tPv/5z8cEI42NjXHDjJNOOkmS4nZVeffdd2PeaOfm5mrKlCn6+OOPdfDgwW6P7ayzzpJlWfrLX/6iv/zlL5o4caJGjx4tqS0cCQaDeuqpp7R582bNmjUrqsQocozx3viHWvCGApVBgwZp/Pjx2r17d7ht7JH276nW1lY99dRTcjgcuuqqq7Ro0aKYf+ecc44kRbX1nT59uiTpT3/6U5ePkci+hYWFkqSdO3fG3FdfX69NmzZ1/aQ6qKiokCRddNFFMfe98cYbMduOO+44FRQU6MMPPwyHUF0ZOnSoLr74Yr3zzjt6++239eyzz+rYY48Nf+0AADgq/bvkCQAA6EhHWJC1s0U0JZkzzzwz7n3HHHNM1GKpgUDAeDweM2bMGNPQ0BDe7vV6zVVXXRV+/K1bt4bve/3118Pdampra8PbW1tbzcyZM+MuyBrqPjN//vy4i7IePHjQrFu3Lmb78ccfb3JycozH4zHXX399eHtzc7PJysoyxcXFRpJ58MEHY44Ndau57777ora/++67xul0dtqtZv78+VEL3VZVVZmxY8cmpVtNqGPQeeed1+k+NTU1Jjs72+Tk5ITHF+pAk5GRYd5+++2YY3bu3Bk13u7ua4wxn/nMZ4zT6TQff/xxeJvf7w8vvNvx+YUWZF2yZEnc8T/zzDNGkrntttuitm/ZssWMGTMm7vfnD37wAyPJfOUrX4nqOGRM2/dVZLeakL/97W9Gkhk+fLiRZO6+++644wEAIFGU1QAAYDMOh0M333yz7rnnHp1wwgmaP3++vF6v1qxZo4MHD2r27NnhWRMhZ555pq699lo99thjmjJlii666CK53W797ne/U35+vkaMGBEu1wi56qqrtG7dOj388MMaP3685s6dqzFjxujgwYPaunWr3nzzTV155ZVatmxZ1HFz5szRgw8+GL4dkpWVpRkzZsRdbyRk2bJlmjFjhv7zP/9Tr776qqZNm6adO3fq+eefl8Ph0OOPPx61aO13vvMd/eEPf9CLL76oE088UV/60pfU1NSk559/Xvv379d3v/vduIvQJiJUUnP11Vd3uk9BQYEuuugiPf300/r1r3+t6667TkOHDtWvf/1rLViwQDNnztSXvvQlnXDCCaqrq9OHH36oXbt2aevWrZKU0L6S9L3vfU9XXHGFZsyYoYsvvlhZWVlas2aNfD6fTjzxRG3YsCGh53jBBReotLRUP/vZz/TRRx/ppJNO0o4dO/Tyyy/r/PPP144dO2KOWbJkidauXasXXnhBEydO1Pnnn69BgwZp586devXVV3XfffdFLV4rSaeffrqmTp2qDz74QG63W1deeWVC4wQAoFP9nc4AAIBo6uWZI8a0tZD96U9/aj7zmc+YrKwsU1JSYi677DKzbds2s3DhwpiZI8a0zTi5//77zaRJk0xGRoYZPny4ueGGG0xtba3Jzc01U6dOjfv4v/vd78z5559vioqKjNvtNiUlJeaUU04xP/zhD80nn3wSs/9LL71kJBnLskx1dXXUfT/5yU+MJFNSUhL3sYwxZteuXebb3/62GTNmjHG73WbIkCFm/vz55r333ou7f3Nzs7nrrrvMlClTTFZWlsnNzTUzZswwv/71r+Pun8jMkU2bNhlJpri4OKo1cjxvvPGGkWROPvnkqO0fffSR+da3vmVGjBhh3G63KS4uNjNnzjSPPvpozDkS2XfFihVm8uTJJiMjw5SUlJhrr73WVFdXH7GVb2czR4wxZseOHebSSy81I0aMMFlZWWby5Mnm3nvvNT6fr9PvT5/PZ37xi1+YU045JTxbqLS01FxzzTVm8+bNcR/nwQcfNJLM1772tU7HAgBAoixj2lc760f79+/Xhx9+qIqKCm3ZskU7d+5UMBjUJZdcErd2NdKmTZv0wgsvqLy8XC0tLSouLtaMGTM0b948ZWRkdHrcwYMH9fzzz+uDDz5QXV2d8vPzddJJJ2nBggUaPHhwsp8iAAAD1ubNmzVx4kR9/etf1zPPPNPfw8EAd/nll+upp57S6tWro1o5AwBwNFKirOaVV17RK6+8kvBxb731lh566CEFg0ENHjxYQ4cO1Y4dO/Tcc89p3bp1Wrp0qTIzM2OO27VrlxYvXqzGxkZ5PB6NHj1a+/bt02uvvaa1a9eqrKys11vhAQCQbiorK1VcXBxVPtPU1KRbb71VUvzFOIFk2r59u5599llNnjyZYAQAkFQpEY4MGjRIJ598skpLS1VaWqrVq1dr7dq1Rzxm//79WrZsmYLBoC677DJdcMEFsixLVVVVuuuuu7RlyxY9/fTTWrRoUdRxwWBQ999/vxobG3XaaafppptuUmZmplpaWvTLX/5S7733nh544AHde++9MbXTAADY2QMPPKBnnnlGs2bN0vDhw1VZWanVq1dr165dOv/88wlH0GueeuoplZeX69lnn5XX69Wdd97Z30MCAAwwKRGOdPxl6q9//WuXx7z00kvhRcPmzZsX3l5UVKTrr79eP/rRj/Taa6/poosuUkFBQfj+tWvXateuXRo0aJBuuOGG8MySrKws3Xjjjfrkk0+0fft2vf/++zr11FOT9AwBAEh/Z599tj766COtXr1a1dXVcjqdmjRpkm655Rbdcsstsiyrv4eIAepXv/qV3nzzTY0ePVo///nPdeGFF/b3kAAAA0xKhCOJMsbo73//uyRp9uzZMfdPmjRJI0eO1O7du/X+++/ri1/8Yvi+0IyU008/XdnZ2VHHZWdna/r06frzn/+sd955h3AEAIAIc+bMidshBuhtr7/+en8PAQAwwKVl3Uh1dbVqamokSccdd1zcfSZNmiSpbZG4SKHPQ/d3dlxFRUVSxipJBw4ciPkHAAAAAABSQ1rOHNm7d68kye12q7CwMO4+xcXFktoWjwvx+/2qrq6WJJWUlMQ9LrR9//798vv9crmO/kt0/fXXR32em5urFStWHPV5AQAAAADA0UvLmSOHDh2SJHk8nk7rm3NzcyVJjY2N4W1NTU0KdS7OycmJe1xouzFGzc3NSRtzpBNPPLFXzgsAAAAAABKXljNHfD6fJB1xVkfoPq/XG94WebuzY91ud9z9j8YjjzwS9bnT6ZQk1dTUKBAIJOUxkDiHw6HBgwdLkg4ePKhgMNjPIwL6Hz8XQHz8bKQOXgsAqYxrVOpxOp2dVpxESstwJBRg+P3+TvcJ3ZeRkRHeFnm7s2NDwUvH/Y/GkCFD4m73+/1Rj4e+Fdmq2ev1cuECxM8F0Bl+NlIHrwWAVMY1KvVEToA4krQsqwmVvkSWyXQUKqcJlddI0WU4odKcjkLbLcuK6WYDAAAAAAAGnrQMR4YPHy6pbZZHqGtNR/v375ckDRs2LLzN5XJp6NChkqR9+/bFPS60vbi4OCmLsQIAAAAAgNSWluHI0KFDVVBQIEnauHFj3H3Ky8slSRMmTIjaHvo8dH9nx5WWliZlrAAAAAAAILWlZThiWZZOPfVUSdKaNWti7i8vL9fu3bvldDo1bdq0qPtCx73zzjsx3Wiam5v17rvvSpKmT5/eG0MHAAAAAAApJi3DEUmaN2+eXC6XNmzYoJdeeim89khVVVW4O8ycOXPCM0xCpk+frpEjR6qhoUEPP/ywWltbJUktLS16+OGH1dDQoNGjR+uUU07p2ycEAAAAAAD6hWU6W9G0D23cuFH33Xdf+POWlhb5fD5lZmZGdYy59957w2uGSNIbb7yhhx9+WMYYDR48WPn5+dqxY4cCgYDGjRunpUuXKisrK+bxduzYoSVLlujQoUPyeDwaNmyYKisr1dTUpNzcXJWVlWnUqFG9+6TVFuTQrab/OByO8Jo0lZWVrCQNiJ8LoDP8bKQOXgsAqYxrVOpxu90qKirqcr+UWHE0EAiooaEhZntra2t4ZoekmG+sM888U8OGDdNvf/tbbdq0Sbt27VJJSYlmzJih+fPnd9qKd8yYMbrvvvu0atUqffDBB9qxY4fy8vJ0+umna8GCBZ223gUAAAAAAANPSswcsStmjvQvUl0gFj8XQHz8bKQOXgsAqYxrVOrp7syRtF1zBAAAAAAAIBkIRwAAAAAAgK0RjgAAAAAAAFsjHAEAAAAAALZGOAIAAAAAAGyNcAQAAAAAANga4QgAAAAAALA1whEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAAAADYGuEIAAAAAACwNcIRAAAAAABga4QjAAAAAADA1ghHAAAAAACArRGOAAAAAAAAWyMcAQAAAAAAtkY4AgAAAAAAbI1wBAAAAAAA2BrhCAAAAAAAsDXCEQAAAAAAYGuEIwAAAAAAwNYIRwAAAAAAgK0RjgAAAAAAAFsjHAEAAAAAALZGOAIAAAAAAGyNcAQAAAAAANga4QgAAAAAALA1whEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAAAADYGuEIAAAAAACwNcIRAAAAAABga4QjAAAAAADA1ghHAAAAAACArRGOAAAAAAAAWyMcAQAAAAAAtkY4AgAAAAAAbI1wBAAAAAAA2BrhCAAAAAAAsDXCEQAAAAAAYGuEIwAAAAAAwNYIRwAAAAAAgK0RjgAAAAAAAFsjHAEAAAAAALZGOAIAAAAAAGyNcAQAAAAAANga4QgAAAAAALA1whEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAAAADYGuEIAAAAAACwNcIRAAAAAABga4QjAAAAAADA1ghHAAAAAACArRGOAAAAAAAAWyMcAQAAAAAAtkY4AgAAAAAAbI1wBAAAAAAA2BrhCAAAAAAAsDVXfw8AAAAAAICBoKnJ0nvvSQ0Nktfr1oQJXnk8pr+HhW4gHAEAAAAA4ChUVLi0cqVHq1Z5VF8f2jpEeXlBLVjQpIULm1Ra6u/PIaILlNUAAAAAANBDy5fnaPbsIq1Ykav6+ui32PX1Dq1YkavZs4u0fHlOP40Q3cHMEQAAAAAAemD58hwtXZrf5X7BoBXe75prDvX2sNADzBwBAAAAACBBFRUulZXlJXRMWVmeKiqYo5CKCEcAAAAAAEjQypUeBYNWQscEg5aefNLTSyPC0SCyAgAAAACgXTAo1ddbqq93qL7eUm2tI+b2gQOWnn22Z2uIPP+8R7ff3kAXmxRDOAIAAAAAGDCMaWupW1cXCjgcqq09fLuuzlJdXfzb9fUONTRYMiaxGSGJqK93aNMml6ZO9fXaYyBxhCMAgLCmJkvvvSc1NEher1sTJnj5qwYAAOhzXq9UV3c4sGgLMKz2bbG32wKQw7f9/t4LN5KhsTG1x2dHhCMAAFVUuLRypUerVnlUXx/aOkR5eUEtWNCkhQubVFrq788hAgCANBIIRJamJDZzo67OUkvLwF4eMzeXPz6lGsIRALC55ctzVFaWF3dBsfp6h1asyNUTT+Ro8eJ6Ws8BAGATxkiHDllxZ250HmpElqakZ7iRnR1Ufr5RXl5Q+flB5eUZ5ecfvt223SgrK6jvfrdATU2JP8+8vKAmTeKPTqmGcAQAbGz58hwtXZrf5X7BoBXej4AEAID00NqqTsOM0O2OC45GBhyBQPqVfrhcptNQo6AgMuCIDkHy840GDQoqM7P7j7V+fZNWrMhNeIwXX9yk7GxmjqQawhEAsKmKCpfKyvISOqasLE+zZ7dSYgMAQB/w+7tfmtJx5kZ9vUMtLekXbliWCQcYHQOOto9tQUbk7ciAIzvbyOqjp71wYZOeeCInoXa+DofR5Zc39eKo0FOEIwBgUytXehL6z1xqm0Hy5JMelZXVd70zMICwWDGAnjCmbeHNrtbZiFxUNDLgaGxM79KUzgKMI93OzTVyOvv7GXRPaalfixfXd2sWbsjixfX8kSlFEY4AgA01NVlatcrTo2OfeCJHmza5lJ1tlJEhZWQYZWbGvx3/88O3O34e7z5Hev5eiAGCxYoBNDery5kb8UtT2m4n+oeIVOB2J16a0nZfW2lKRkZ/P4O+Eyo37mz9thCHw2jJknpdfTXlyanKMsbwZ49+UlVVJZ+P3tb9xeFwaNiwYZKkyspKBYPBfh4R0Dvq6y1t2eLSp5+6wh8/+sitrVvTIx93uUJhidqDlnifRwYzRwpq2m673UcObY4c6KjPpuuifx1pseIQh8OwWHEf4/9vJKqtNCV+6Un07filKa2t6XfRD5WmhGZu5OWZ9lAjfqlKxxkcWVl9V5oyUFRUuPTkkx49/7xH9fWH/7KTlxfUxRc36fLLCdP7i9vtVlFRUZf7EY70I8KR/sUvVxhIvF5p+/a24OPTT51RYUh1dZrMTU0jkbNbehbSJHemjSs9cq600t3FikOWLq0jIOkj/P9tP8Fg16UpR5q5cehQek5B9HgSK00JzdwIlaYw87J/tLQ4deBASXsZZrVKS32UYfaz7oYj/DoFAGnCGKmy0hEzC+TTT13ascOZltN205XXa8nrTZ2vt8MRf4bL0YQ2ic2miQ1t0vkvjixWDCSXMVJLi9XpbI3IgCMy1Ijcno7/x4VKU+KVp3QWakSWprjd/f0M0BMej9G4cW23Kyv9CgYJRtIF4QgApJiGBisq/Gj76NSnn7rU1JTMPwMZSYn/spmbG9Szz1bL4bDU2no4KPB6O34utbZanXwefbvt2Hifx57fmPT7Bbm3BYOWWlostbT090gOc7vjByfJDm26s25NaHZNdwMbFisGYvl8ijtzIxR2xAs2IhcZTaVAubscjtjSlCOFHR27qGRlpXdQDNgN4QgA9AOfT9q+3Rme+RE5C2T//uSVwViW0ciRAY0f79e4cf72j22fL1uWo8cfz034nJdc0qSpU/vnr+PGtNWOxwYx0Z8fTWjTnaAm8nw+H7/5xuPztX1tDqVIpYllxQYn8YIal8vonXcye/QYzz7r0S23NGrw4CBviHoRnYN6JhhsC9+7KkfprDQlueF838nJiS1DORxmdN4aNj8/qJwcSlMAOyEcAYBeYoy0b58jziyQtjKYQCB5754KCoLhAORwCOLX2LF+ZWfHP+aKK5q0cmVOQn8hdziMLr+8KUmjTkJbjF4AACAASURBVJxlSW5326yEnBypbfZL/woG1Wlw0lUw01uhTTpOP+9txrTNrGlp6b2vTWOjQ5/97DA5nUaDBhnl5gY7fGybKh//Y+z+vDGLZvfOQcZIzc2dlabEn8XRsTQlHWfeZWR0PlvjSJ1TQvuwJhOA7mJB1n7Egqz9iwXdkCyNjVaHGSCHF0RN5iJwmZlGY8f6o0KQUBAyeHDPLuUsOjkwxZtdk5wSqJ6XRKFncnOPHKZ0FbCEPqb72gUDpXOQ15tYaUpb69jDt9NxplqoNKWzTilHWmA0P7+tNAVIJ7zHSD0syAoASeTzSTt2OGNKYD791KV9+5LbDWbkyMOlL5GzQEaODMiZ5MYzoTcR3XnTsWRJva6+OnXfdOAwl6utBbLHI6XC7BpjjjS7prdn08SfXZPMmVu9qbHRocZGqbLy6H74s7LihSmHQ5XuzGTJze2fNRS6G+IGg1Z4v94KSAKBw6Up3S1HiQxBmpvTcypQbm780pPOylE6lqZQZgYgHTBzpB8xc6R/keqiI2OkqqrYbjBbtrSVwfj9yfvtLj8/GBV8hG4fe2xA2dl9f1muqHDpySc9ev55j+rrD//ynpcX1MUXN+nyywf2dHXYTyAQf3ZNXZ2lr399aI9mfTkcRqNGBdTUZKmx0dGrJTz9xeXqfnnQkYIWj6d7JUMVFS7Nnl2UcPnfmjVVca9ZxrStWdJVOUpnszgaGtKzNCUrK3a9jc5KUzp2TqE0BUgM7zFST3dnjhCO9CPCkf7Fhcu+Dh2ytHWrM25L3IaG5P1VLyOjrQwmMgQZPz6gceP8KbtgY0uLUwcOlLQvdFit0lIfCx3Cdn70ozytWJH4YsWLFjVGdavxetvK7hob295Ux3601NDg6OTj4f2SWZ6XKiyrLWTpKmh5++0M/f3viS+QO2mSTxMm+OOWpiQz6O4rTmfHWRpdr7cR2SaW0hSg7/AeI/UQjqQBwpH+xYVrYPP7pZ074wcgRzs9vaPhw2NLYMaP92vUqOSXwfQ2fi6A5M9WOFqBQFuoGz9gSSxoYbHe/jNo0JFKUzrrptK2ndIUIH3wu1TqYc0RAAOeMVJ1dcduMG3rgmzf7krqwnV5ecH2speOC6IGmFkBDDClpX4tXlyf0GLFixfX91rpmdOp9tkBRlLPf8kOdTtpaDgcmETPbOlewNLY6FBrq/3eqWdlRa+z0dVsjY6lKekWlgOA3RCOAEh5TU1WVAeYyH+R62McLbfb6JhjQuFH9GyQIUNSswwGQO8YiIsVW5bk8bSt91FSIkmBHp+rtVU6dMgRFbR0f0bL4fubmvquZMjpPFyS0lnnlI63I4OQzMSrewAAaYRwBEBKCATaymA6LoT66acu7d2b3D+3DRsWiFkIddw4v0aPDrDoHICwa645pNmzW1msOI7MTCkzM6jBg4/uPH5/W8lQKCyJDE7+9S+3fvGLQT0+97331mraNG844PB4KE0BAHSONUf6EWuO9C/qAfueMdLBg6FuMNHrgWzf7pLXm7zfWnNz28pg4nWDycnhstcZfi6A+FisuO81NVn63OdKejRDMC8vqPXr9/VL9y8A9sbvUqmHNUcA9Jvm5rYymI4LoX76qUt1dcmbQu1ytZXBdCyBGTfOr6IiymAAJI/HYzRuXNvtykq/gkHedPc2j8dowYKmHnUOuvjiJoIRAEBCCEcA9EggIO3eHdsNZssWp/bsSe6lZdiwQMxCqOPHt5XBuN1JfSgAQApZuLBJTzyRk3DnoMsvb+rFUQEABiLCEQBH1FYG4wzP/AiFINu2uZLarSAnJ9hh9kcg3B0mN5e//gGAHaVa5yAAwMDFmiP9KPiFL0gbNiR0TN0dd6j5a1+L2Z793HPK/9GPejSOyvLyuNuHfO1rcic4PklqXrBAdXfdFbPdtXmzhn75ywmfT5IO/O//ynfSSTHbB919t3KeeCLh8/lLS3XwD3+IWw9Y8rnPyWpsTPic9bffrqYrr4zZnvWHP6jg1lsTPp8k7Xv/fZlBsYvRFS5apMy33074fC1z56r25z+P2d66tVL1Z1+vcjNBm4MTVB6coM3BUm0KluqgjnK1vQhO+TXO2qaJjs2a6Kho+2ht1iTHZg2z9smypEBJiarefDPu8UUzZ8q5b1/Cj9t4001q/Ld/i9me8eabGnzNNQmfT5L2v/66gsOHx2wvuPlmZf3pTwmfr/ULX1DNr34Vs91qaFDJtGk9GmPtAw+o5bzzYrZ7Hn9ceffc0+lxjvZ6pGCH/x5Mbq72rVsX95ih558vV0VFwmM8dMUVavj+92O2u//xDw35+tcTPp8kVb/8svwTJsRsz//hD5W9alXC5/OdeKIOPPdc3PuGTZqU8PkkruUdHc21vPr3v497X7Kv5dl//KMK26/lHX82utJX13LH3r0qnjUr4fNJ0sHly+WdOTNme+4vfqHcX/4y4fMl+1r+oPcGfcd3t4Km89JMhwL6acb3dXPGI90+70C+lneGa3ksruWJSedreV/9Xt7Z71KR7Hgtl/rp9/ITT5SjG//fMnOkHzmamqQEf9gtf/y/hFh+vxw9uHAc8bGam3t2ztbW+NuDwZ6PMRC/3aDV2tqjc1pNnU+3tRobe3ZOrzf+HSny2gRlacfBPP3jjcyYBVF37x4uY9YmbXzFxQFNzNiqz+z6iyapXBO1SZNUrmO1VW7jb+se2UkHSZPbeW2549ChpL421tF8T3byn53V0tKzMTY3d3pfj8fY2fXC6+3WOTu+BTnScmJWU1PPnndn14tAoOfPu7OFz3p6veiF14ZrebS0uJYHAlJDg6TYn42e6ulrY7W0xL/DmJ5/T3byc9Pd60XMUJJ8Lb9N/6WZVwzWI84bYzsHeby6oukRXa9HdJy3XOrkJYw/0IF/Le+Ia3ksruUJSudreR+/Nkf6/8KO1/LQWOJu783fy4/wPRaJcAQYYA6qUOWapE2aGPVxsyaodU2WtCY5j5OjRk3UJo09fbDGTh8StR7IoEFGg376iAbdf39yHgwAYHsTB+9X2X/U6wc/OBTVOWjyntUas6hnfwkGACCEcKQfBT0e6QhpXDzGFf8lMy6Xggmeq8vHys7u2TkzM+Nvdzh6PkanM+5mk5nZo3Maj6fz+3Jzj/hXlU6Py8iIf0cvvDbNGXnalH2KNpkJ2hScoE3B0vDHAxqStMdxyq9jrW3tJTAVmujYpIlWhSY5Nmu4VSnLkg7eHH/6nsnI6NHzDubkHPE+qyevdyevjTma78lOWuGYrKyefU9mZ3d6X4/H2Nn1oovX5khlNZ0xHk/Pnndn1wuns+fP29HJ32l6er3ohdeGa3m0tLiWO51S+3TqRMtqOn2sHr42Jisr/h2W1fPvyU5+blLxWt6xc5Cr1nAtTwDX8lhcyxOUztfyPnptulNWY/drecz23vy93OPp1qxP1hzpR1VVVfL5fP09DNtK9R7kwaC0d68zpgRmyxaXdu1yypjkLYZaVBSIaoMbWhB1zBi/Ovu/BQNTqv9cAP2Fn43UwWsBIJVxjUo9brdbRUVFXe7HzBHYVlOTpffeU/u0XLcmTPDK4+n7rLC21goHH5HdYLZudaqlJVmV7VJ2dlDjxsWGIMce61d+PhkpAAAAAPsiHIHtVFS4tHKlR6tWeVRfH9o6RHl5QS1Y0KSFC5uS3gKwtVXavt0VNfsjNBvk4MH4UxN7wuEwGjMmEF77IzIIGTYs2OkMVQAAAACwM8IR2Mry5TkqK8tTMBhbklJf79CKFbl64okcLV5cr2uuOZTQudvKYBxRsz9C/3budMZ9zJ4aMiQQMfvj8GyQMWP8nZaWAgAAAADiIxyBbSxfnqOlS/O73C8YtML7xQtI6uqsmABky5a2Mpjm5uRNzcjKii2DCf0rKKAMBgAAAACShXAEtlBR4VJZWV5Cx5SV5cntNmpqckQtiFpdnbwyGMsyGj06EBN+jB/v1/DhlMEAAAAAQF8gHIEtrFzpSbisJRi09MMfFiTl8QcPDmjcuECHbjB+HXOMX5118QIAAAAA9A3CEQx4TU2WVq3qvH96smRlGR17bOxCqOPG+VVYSBkMAAAAAKQqwhEMeOXlLtXXJ6c+xbKMRo3q2A637fMRIwKUwQAAAABAGiIcwYDX2Hh0XWK+/vVDOuusVo0f31YGk52dpIEBAAAAAFJC2ocjtbW1euGFF7R+/XodOHBAWVlZGjdunM4//3xNnTq10+M2bdqkF154QeXl5WppaVFxcbFmzJihefPmKSMjow+fAXpbbu7RlbR861tNmjrVl6TRAAAAAABSTVqHIzt27NAdd9yhuro6ud1ujR49Wk1NTdqwYYM2bNigSy+9VF/5yldijnvrrbf00EMPKRgMavDgwRo6dKh27Nih5557TuvWrdPSpUuVmZnZD88IvWHSJL/y8oI9Kq3Jywtq0iR/L4wKAAAAAJAq0jYcCQQC+ulPf6q6ujpNmTJFt912m/Ly2lq1fvTRR7rvvvv0zDPPaOLEiZo8eXL4uP3792vZsmUKBoO67LLLdMEFF8iyLFVVVemuu+7Sli1b9PTTT2vRokX99dSQZB6P0YIFTVqxIjfhYy++uEnZ2SymCgAAAAADWdouH7l+/Xrt3btXbrdbN9xwQzgYkaTjjz9eF154oYwxWrVqVdRxL730knw+n0488UTNmzdPltW2HkVRUZGuv/56SdJrr72m2travnsy6HULFzbJ4Ugs5HA4jC6/vKmXRgQAAAAASBVpG46Ul5dLksaPH6+ioqKY+6dPny5J+vjjj1VXVydJMsbo73//uyRp9uzZMcdMmjRJI0eOVCAQ0Pvvv99bQ0c/KC31a/Hi+oSOWby4XqWllNQAAAAAwECXtmU1jY2NkqTBgwfHvT+03RijLVu26OSTT1Z1dbVqamokSccdd1zc4yZNmqTdu3dr8+bN+uIXv5iUsR44cCDqc6fTqYKCAlmWJQe9X/vMddc1y7Is/fjHgxQMdt7BxuEwWrq0Qddc06w0zg+BHom8JnF9Ag7jZyN18FoASGVco1JPqFqkK2kbjng8HknSwYMH494fuX3Pnj06+eSTtXfvXkmS2+1WYWFh3OOKi4slSZWVlUkba6hcJ+TYY4/Vvffeq6FDhybtMdA9ixdLX/ua9Mgj0sqVUvukIklSfr60cKF0/fWWjjsuT1Jep+cB7CB0PQQQjZ+N1MFrASCVcY1KL2kbjpSWlkqStmzZourq6pigYe3ateHboVkmhw4dktQWrHSWHuXm5kYdg4HnuOOkBx+UfvIT6V//khoapEGDpMmTpZyc/h4dAAAAAKCvpW04Mm3aNBUWFqqmpkY///nPddttt4Vng6xfv16/+c1vwvt6vV5Jks/nkyS5XJ0/7dB9oWOS4ZFHHon63Ol0SpKqq6vl97OmRX9xOBw65ZS2NHf//v1qaAiqoaGfBwX0M4fDEf4rx/79+xUMBvt5REBq4GcjdfBaAEhlXKNSj8vl6lbVRtqGIxkZGbrtttt09913a+PGjbrhhhs0YsQINTY2qqamRkOHDtXYsWP1ySefKCsrS1JbOY2kIwYSofsyMjKSNtYhQ4bE3W6M4YclRQSDQV4LoAN+LoD4+NlIHbwWAFIZ16jUYEz3upam9Qoxxx13nO69917Nnj1bBQUF2rNnjyTp7LPP1j333BP+RiwoKJAk5bTXTDQ1NXX6BQqV04TKawAAAAAAwMCWtjNHQoYNGxaz4KkkBQIBbd++XZI0btw4SdLw4cMltZXX1NTUxO10s3///vB5AQAAAADAwJfWM0eOZMOGDWppaVFhYWE4HBk6dGh4FsnGjRvjHldeXi5JmjBhQt8MFAAAAAAA9KsBGY74/X49++yzkqRzzjkn3F/asiydeuqpkqQ1a9bEHFdeXq7du3fL6XRq2rRpfTdgAAAAAADQb9I6HFm/fr02b94cta26ulr33Xeftm7dqlGjRmnevHlR98+bN08ul0sbNmzQSy+9FF57pKqqKtxVZs6cOeEZJgAAAAAAYGBL6zVHPvzwQ73yyivKyclRcXGxvF6v9uzZI2OMRo0apf/3//5fuENNSHFxsa677jo9/PDDevrpp/XKK68oPz9fO3bsUCAQ0Lhx43TZZZf10zMCAAAAAAB9La3DkVNOOUU1NTWqqKjQrl275Ha7NX78eH3+85/X3LlzY4KRkDPPPFPDhg3Tb3/7W23atEm7du1SSUmJZsyYofnz5ye1jS8AAAAAAEhtaR2OTJkyRVOmTOnRsZMmTdLtt9+e5BEBAAAAAIB0k9ZrjgAAAAAAABwtwhEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAAAADYGuEIAAAAAACwNcIRAAAAAABga4QjAAAAAADA1ghHAAAAAACArRGOAAAAAAAAWyMcAQAAAAAAtkY4AgAAAAAAbI1wBAAAAAAA2BrhCAAAAAAAsDXCEQAAAAAAYGuEIwAAAAAAwNYIRwAAAAAAgK0RjgAAAAAAAFsjHAEAAAAAALZGOAIAAAAAAGyNcAQAAAAAANga4QgAAAAAALA1whEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAAAADYGuEIAAAAAACwNcIRAAAAAABga4QjAAAAAADA1ghHAAAAAACArRGOAAAAAAAAWyMcAQAAAAAAtkY4AgAAAAAAbI1wBAAAAAAA2BrhCAAAAAAAsDXCEQAAAAAAYGuEIwAAAAAAwNYIRwAAAAAAgK0RjgAAAAAAAFsjHAEAAAAAALZGOAIAAAAAAGyNcAQAAAAAANga4QgAAAAAALA1whEAAAAAAGBrhCMAAAAAAMDWCEcAAAAAAICtEY4AAAAAAABbIxwBAAAAAAC2RjgCAAAAAABsjXAEAAAAAADYGuEIAAAAAACwNcIRAAAAAABga4QjAAAAAADA1ghHAAAAAACArbn6ewAAAAAAAAwETcGg3quvV0MgIG9zsya43fI4mJOQDghHAAAAAAA4ChVer1bW1mpVfb3qg8Hw9jyHQwvy8rSwoEClGRn9OEJ0hQgLAAAAAIAeWl5To9nbtmlFbW1UMCJJ9cGgVtTWava2bVpeU9NPI0R3MHMEAAAAAIAeWF5To6VVVV3uF5TC+11TWNjLo0JPMHMEAAAAAIAEVXi9KutGMBKprKpKFV5vL40IR4NwBAAAAACABK2srVWw692iBCU9WVvbG8PBUSIcAQAAAACgCy3BoCq8Xr1+6JD+v5oaPV1X16PzPF9fr6ZgorEKehtrjgAAAAAAbM9njPb4fNrp92unz6cdPp92tX/c6fNpXyCQlMepDwa1yevV1KyspJwPyUE4AgAAAAAY8ALGqNLvbws8Qh/bg4+dPp/2+P0Jl8n0VCMzR1IO4QgAAAAAIO0ZY1QdCBwOPCJmgOz0+bTb55OvvwfZLtfBChephnAEAAAAAJDyjDGqDQZjS17aQ5CdPp9ajOm1xx/mdGqU260xbrdKXC49Xlvbo8fLczg0KSOjF0aIo0E4AgAAAABICY3BYFTw0TEE6c1ylMFOp8a4XBrtdof/jXG7Ncrt1iiXS1kdZnu0GqMVPeg8c3FenrKZOZJyCEcAAAAAAH2iORjUrvagI3K9j9BskNpeDD/yHI7DgYfLpTERIchot1s5CQYWCwsK9ESC7Xwdki4vKEjocdA3CEcAAAAAAEnhbe/4Em/dj10+n/YnqeNLPNmWFZ7pEQ4+IkKQfKczqY9XmpGhxUVFWlpV1e1jFhcVqZSSmpREOAIAAAAA6JZQx5eokpeINT8qe7HjS4ZlaVRE2Us4CGnfNsTplGVZvfTo8V1TWChJKquqOuLzdkhaUlSkq9v3R+ohHAEAAAAASJKCxqgqsuNLhxkgu30++XvpsZ2SRrQHHZEzQEJlMCUulxx9HH50xzWFhZqdk6Mna2v1fH296iNKg/IcDl2cl6fLCwqYMZLiCEcAAAAAwCaMMappX/Q0cq2P0KKnu/3+Xuv4YkkqCZW5RIQgoZkgw10uuVIw/OiO0owMlRUX6wfFxTqQm6uGQEDe2lqVut3ysPhqWiAcAQAAAIABpL595seuOIue7vT5dKgX290OdToPl7106Pwy0uVS5gAPCjwOh8bl5UmSKltbFezFBWaRXIQjAAAAAJBGmoLBuCUvoRkgvdnxpaC940vUuh/ts0FGMUsCaYxwBAAAAABSSGswqN0dAo/IRU+re7HjS06Hji8dO7/kJbnjC5AqCEcAAAAAoA/5jdHe9pKX0FofkWUw+/x+9VbhS2Z7x5fItT4i1/4odDj6vOMLkAoIRwAAAAAgiYLGaJ/fH1XuElkGs8fvV2/N/XBJGhmx5kfHGSBFTmdKdnwB+hvhCAAAAAAkwBijA6F2tx3LX9o7vnh7sePL8Ig1PiIXPR3jdmuYyyUn4QeQMMIRAAAAAOigNhCIW/ISmv3R3IsdX4ojOr6E1voIhR8j3G5lEH4ASUc4AgAAAMB2DrV3fIlpdds+E6S+Fzu+FEZ0fIkseRnT3u42m44vQJ8jHAEAAAAw4LQEg9oV0eGlY+eXg73Y8SXX4dDoDouehm6Pcrk0iI4vQMohHAEAAACQdnzGaE970LErzgyQfb0YfmRZVlTJS8fOLwV0fAHSDuEIAAAAgJQTMEaVoZkfcWaA7PX71VuFL261dXyJmvkR0fllqNNJ+AEMMIQjAAAAAPqcMUZVgUB0yUvEoqe7fT75eumxHZJGdOjyEtn5pYSOL4DtEI4AAAAASDpjjGqCwbglL6GZIC292PFlmNMZnukxusPaH8NdLrkJPwBEIBwBAAAA0CONwWBU8LGjQwDS2IsdXwY7neGZHh1ngIxyuZRFxxcACSAcAQAAABBXc+TMj/bZHuGOLz6fansx/Mhrb3c7pj3s6DgDJIfwA0ASEY4AAAAANuU1RrsjZ3506PxS1YsdX7It6/BaH3E6v+TT7hZAHyIcAQAAAAaogDHaGzHjY2eHGSCVfr96a9WPDMvSqE4WPR3jdmswHV8ApBDCEQAAACBNBY3R/o4dXyI6v+z2+eTvpcd2qq3dbajkJTQDJFQGU+JyyUH4ASBNEI4AAAAAKSrU8WVHh+AjFIbs8vvV2ksdXyxJJaEyl/YZIJHrfgx3ueQi/AAwQBCOAAAAAP2oPhCIW/Kyq33boV5sdzvU6TwcenTo/DLS5VImi54CsAnCEQAAAKSNpmBQ79XXqyEQkLe5WRPcbnlS/A18UzB4uL1tnEVP63qx40tBe8eXqHU/IhY9zU7xrx0A9BXCEQAAAKS8Cq9XK2trtaq+XvURYUKew6EFeXlaWFCg0oyMfhlbazCoXR0Cj9AMkJ0+n6p7seNLTryOLxGdX/Lo+AIA3UI4AgAAgJS2vKZGZVVVije/oj4Y1IraWj1RW6vFRUW6prAw6Y/vN0Z7IsKOjp1f9vVix5fM9o4vHYOP0OeFDgcdXwAgCQhHAAAAkLKW19RoaVVVl/sFpfB+iQYkQWO0z+/XTr8/arHT0Lofe/x+9dbcD5faOr6Mbm9x23EGSJHTSccXAOgDhCMAAABISRVer8q6EYxEKquq0uycnKgSG2OMDnRY9DQyBNnt98vbix1fhke2uo1Y9HSM261hLpechB8A0O8IRwAAAJCSVtbWxi2lOZKgpP+srNTkzMyodT+ae7HjS3F7x5d4i56OcLuVQfgBACmPcAQAAKAL6dghJZ0FjVGV36/n6ut7dPx7LS16r6UlaeMpjOj4Ern46Zj2drd0fAGA9Ec4AgAA0IlU7pCSinzGqDEYVGMwqIbQx0Ag+vMOt+N9bOzF1rbx5DocGt1h0dPQ7VEulwbR8QUABjzCEQAAgDj6u0NKXzHGqLU91IgXVkRtCwSOGGy09GLpytHIsqyo9rYdO78U0PEFAGyPcAQAAKCDvuiQcrSCxqjJmLgzM7qaoRGe3dF+rK9PR943vjtkiL7g8WiM262hTifhBwDgiAhHAAAAIiSrQ0pn/PFKT7o5M6NjwJGa8zSOTo5laZDDIY/Doe0+X49a6OY5HLq2sJC1QAAA3UY4AgAAEKGnHVL+o7JSp3s8XZag9GbXlP7ikDTI4VCuwxH/o9N55PvbP+Y4HFFtbX+0f79W1NYmPJ6L8/IIRgAACSEcAQAAtmWMUU0wqP1+v/a3t339n7q6Hp3r/ZYWvZ/EDil9IcOyugwsugo6BjkcyrasXilbWVhQoCcSDKscki4vKEj6WAAAAxvhCAAAGHBag0FVBwLa5/erKvTR79e+QEBV7UHI/vbb6bjehqe99CTRmRnhQMPpVI5lKTPFZ1eUZmRocVFRt9Z/CVlcVEQHIQBAwghHAABAWjDGqC40yyMQCM/2qArdjthW28etYLvDUhelJ10EHaHbOQ6HXDZaXDS00G1nnYNCHJKWFBXp6jTuHAQA6D8JhyP33Xefzj33XJ1wwgm9MR4AAGAzPmPaZnN0CDw6zvaoCgTUmuLrddw6eLCmZGZGzdAI3fb0UumJHVxTWKjZOTl6srZWz9fXqz4i/MpzOHRxXp4uLyhgxggAoMcSDke2bdumO++8UyNGjNDcuXM1a9YsZWVl9cbYAABAmjLGqCEYDAcekSHHvg6zPQ4GetKPJDkKHA4Vu1wqcjpV7HKp0OnU/9TV9SiEyXM4dNPgwSwE2ktKMzJUVlysHxQX60BurhoCAXlra1XqdsvD1xwAcJQsYxL7398Yo3Xr1umPf/yj/vnPfyorK0szZ87U3LlzNWrUqN4a54BUVVUlny8dK50HhpZAi6od1WpobZC30asJ+RPkcXv6e1hAv3I4HBo2bJgkqbKyUsEULE1A//Ibo+qIGR5xZ3u0b2vpp1keLklFLpdKnE4VuVwqdrlU3B5+RN4ucjrjrrnR0w4piwoKVFZcnIRngCPhOgUglfEeI/W4HXkt/gAAIABJREFU3W4VFRV1uV/C4UikPXv26I9//KPefPNNNTc36/jjj9fcuXM1bdo0OUjwu0Q40j8qaiu08l8rtWrzKtV768Pb8zLytGDCAi2cvFClBaX9OEKg//Cmw74aIzq2HGm2x4FAQP1V2JLXYZZHvMCj2OVSgcMhx1GUr1R4vZq9bVvCHVLWjB1LWUcf4DoFIBXxHiN19Uk4EtLY2Kj7779fH3/8sSRp6NChmj9/vs4555yjPfWARjjS95b/c7nK1pYpaDr/RcphObT4tMW65oRr+nBkQGrgTcfAEjBGB+IsVhpvMdOmfprl4ZTCYceRZnsUOZ19Wq6yvKYmoQ4pS4uKwguHondxnQKQaniPkdq6G44cVbeampoa/fnPf9bq1atVW1urz372szr99NP1/vvva8WKFdq9e7euvPLKo3mILtXV1enFF1/UBx98oP3798sYo8GDB+v444/X/Pnzw/95drRp0ya98MILKi8vV0tLi4qLizVjxgzNmzdPGfzVZ0Ba/s/lWvru0i73C5pgeD8uXgBSUVOcji3xZntUBwIJzX5IplyHQ0VOp0oiZ3rEme0x2Ok8qlkevYUOKQCA7uA9xsDRo5kj//rXv/THP/5R77//vpxOp2bOnKnzzjsvas2Rl19+Wf/3f/+nxx9/PKkDjrRnzx4tWbJEdXV1cjqdKikpkdPpVGVlpXw+nzIzM/X9739fkydPjjrurbfe0kMPPaT/n707D4+6vNc/fn9nyU4SQhL2nRA2ASkigqUErLgBIkqtRTytFaXWauuxrbUiWj1qj56r6lFcfrXiVlmCOy5FQBGtiAKCHFaFQCBkJ4EsM5mZ3x9hhgyZCTPJzGSZ98srV5LvNp9knCFzz/N8HqfTqbS0NKWkpCgvL08Oh0MDBw7UokWLFBsbG7a63Rg5Ejl7y/cqZ0VOk2nu6UyGSWuvXMvwN0QV3pFtPU6XS6UOh++mpQ3DD4dDx1vpfjFJSj9tSou/0R4dpUHmXpuNFVLaGJ6nALQVvMZoH8I2cuT222/XoUOHlJ6erquvvlpTp05VYmJio+MGDx6sqqqqYC8flL///e86duyYsrOzddttt6lLly6SpMrKSi1evFibNm3SU089pSeeeMKzdF5hYaGefvppOZ1OzZ07V9OnT5dhGCoqKtIDDzygffv26eWXX9b1118f1toRWUt2LGn8pGWKkxL7SeYEyVElndgvOWs8u50up17c8aLum3BfRGsF0LFUO51ey9L6G+1R5HCotdZsiTcMdW0wfaVrw88NAo8uZrPMbXCURzixQkrbU2Wv0sb8jTQ7BNAqHE6H6lx1qnPW6dltzwYVjEi8xmjLgg5HOnXqpNtvv/2MTVcHDBigxx57rEXFNaW2tlbbt2+XJN1www2eYMRd469+9Stdf/31KiwsVH5+vmdUy1tvvSW73a5Ro0ZpxowZnnMyMjK0YMEC3X333Vq9erVmz56t1NTUsNWPyKmyV2nFnhWnNsT3lnpcLnW7ULIkndped1wq+FA6/IZUfVCS9OrOVzW512T1T+mvbondFG+Jj3D1ANoip8ulcqfTE3i4R3v46udR0UrvahuSujQY5dFUP48kXuSfUYLJpAHJyZKkgtpaRiu0ApodAu2H0+WU3WlXnbPO82F32uVwOXxud4cNdqddDudpx7j8bD/DNZu73et2fNTlCkFb8uV7luuP5/yRYLeNCTocWbRoUWAXtlj89vsIhbq6OrlnBGX6WDYvKSlJSUlJqqys9PwB43K59OWXX0qScnJyGp2TnZ2tnj17Kj8/X5s2bdIFF1wQtvoRObvKdp36I6rnbGngAskwNz7QkiT1ukLqOVPat1jKz1W1o1rXfnCt55DOsZ3VPbG790dS/eceiT3UPbG7Eq2NR1IBaB9qnE4VN1iO1t9oj+K6OrXWpMg4w/AON9zBx2mjPdLNZlmibJQHOq6mmh1W2Cr0/LfP64UdL9DsEO2KO0Dw92K84Yt3d0DgtS2MAUFLt4ciQOjIKmwV2l2+W6MzRrd2KWgg6HBk7969Ki4u1vjx4xvt+/e//62MjAwNHDgwJMU1JTExUV26dFFJSYl2796tkSNHeu0/fPiwKisrlZiY6AlpiouLVVZWJkkaMmSIz+tmZ2crPz9fe/bsCVk4UlJS4vW92WxWamqqDMNgyeMIqKo7Ob2r52xp0K/PfIJhPnVcfq7XrrLaMpXVlmlH6Q6/pyfHJHuCkx5JPbyCFPf3yTHJnqleQFtSLWljRYUqHQ7Za2s1uANMHXCdHOXhCTcahByekR8nP5e34miAtNN6ebhDjq6njfLoZDLx/NEKGv57zb/dkfXsN88G1ezQMAzNHzk//IUhIlwul9eL76be0Q/4GB9BQyAhRSCjCoK5frDTMdCxVNVV8e9JhAT6d1PQ4cirr76qwYMH+wxHDhw4oNWrV+vPf/5zsJdtlquvvlpPPvmkFi9erOuuu07Dhw+X2WzW7t27tWTJEhmGoZ/97Gee1WeOHDkiqb4hS2c/XeXdo1AKCgpCVueCBQu8vu/fv78efvhhpaenh+w24F9fR9/6qTQDF5z54IYGLpBKN3qm2ASqwlahCluFdpXt8ntMojVRvZJ7NfnRJb4LL4AQMTtPnNBThw/rxYICHXOc6nyRYjZrXrdu+lWPHhrio79Ua7I5nTpqs+mIzaaChp9ra72+L7DZZGulZWpjDUPdYmLUPTa2/nNMjNdn99eZMTGK4Q+kdsPXiFWEx87inbr33/cGdc69/75Xc8bM0ZB032+EdUQNAwS7w976XzvtsjvsXuFCc69HgIDWYsiQ1WyVxWSR1WT1+tpisqjOWaeDFcG9Tmiob7e+YZ1pgeAFHY4cOHBAl156qc99WVlZ+te//tXiogL1ox/9SHFxccrNzdX//M//eO3r27ev7rzzTo0efWqo0okTJyRJCQkJfl90JiXV96A4fvx4mKpGpA3PGK6Y3nNk8zWVpimGWeZeV2iGOU8Fxwt0qOKQDlcelsPV8paJJ+wntKtkl3aV+A9QYs2xjQKTnp16en3fNamrTAYvqNAyfzt4ULfv2+dzudJjDoeeyM/Xk/n5enTgQN3Wu3dYa3G5XDpWV+cVbPgLP0rq6sJaS1PSLBbvsMNP+JFqsRByAi3w1JdPNavZ4eIvF+uxi71737lcrpC/cA9FcBCKr0PxtwnQXKcHBy3+2rDIarZ6QojW+tpsavq1wwnbCfX8n546Vnss6N9ZSmyKhmcOb+6vHGESdDhSU1Mji8X3aSaTSdXV1S0uKlAul0tHjx5VZWWlTCaTMjMzZbFYVFBQoLy8PK1evVqDBg3yBB7uZXP91d9wn81mC1mdixcv9vrebK5/oBUXF6uuFf+4jxZVTqfU9cJmnevqPkP2TsnqYTKpt+qXsbQ7alRTV6Vq+3HV2E+oyn5cVfZKHbdV6LjtmE7UVsjhtElySi6H5HJ/dnh/72//ye21Lqf2ORzaV1oolRyRXP9udJ7ZkDLiuqhbfIa6JmSoe2Kmuid0Vc+EbuqR2E29krqpe2I3WUxBP9QRJZ4tLdU9hYVnPM4p6bf79qmislLz09KCvh27y6XiBsvTHj19isvJaS5FdXWqaaVRHlbJ06zUM6WlQT8P97SWDLNZsf5GebhcUm2tVFurWklHI/kDIKzcf2dI9Svf0ZA1fOwOu0prSnXo+CH9/eu/N+saT2x8Qku2LFGdq84zlYEAAa3JarLKbDJ7XnhbjFMjENwfVpNVZsPse/vJc5s8xr3dHPz1gznGYpzaZjLa4VRPl6TTXoI5Tv5X/6934K7MulJ/3x7889SVWVeqoqRCFao488FoMYvFEtCsjaBfMWVmZurbb7/VqFGjGu3bsWNHRKeKPPfcc1q9erWys7N17733ev5oOXbsmBYvXqyNGzfq6NGjevjhh2UymWS1WiWpyUDCvc89FScUGq6k05DL5eKPqwj4v+pq2UzNuz+dhknv+BxFZJGUKplTJbOkuJZU2HwOSQUnP7zUSTom6dhxSXslZ50MuWSSSyZJFsOQ2TBkNUyyGibFmMyyGCaZJZkNw/PZIslkGPXHn7bPfPI6nuuFen+Axzb3NhpuNynwuYgdyV6bTfcGEIw0dG9hoSYnJGhQTIxcLpeOO52nmpU2WJb29NVbSh2OVmvNlmIyeS1H27CvR8MGpp2D6OXBc3d0czqd/D8QhJq6GpXUlKi0plQl1SUqqTn1UVpdeur76vpjjtmCfxf2dC65QnIdRFbDF92nBwlBbW8QPjTafqYAwLD4DgV8bD9jSHFym9kwd9i/M1wul2eRjGg0b+g8/ePbfwQ1ws1kmDRv6Dz+HYmgQP8fDTocOe+88/Tmm2+qV69emjRpkmf7J598onfffVczZ84M9pLNsn//fn300Ucym8269dZbvUKZlJQU/eY3v9Ett9yiAwcO6LPPPtP555+vxJPz5auqquRyuXw+Sbmn07hHm6D9Ox7FT9geJotcqg9THNKpVTZcJz+c7j3Ry28w1OBzi/afIZwJVejjtf8MdT1RWupzKk1TnJKuOnhQ8SaTCuvqVN1Kjy+LpPTTVmzJ9DHaI91sVjy9PBACVfYqbczfqMraStmO25SVkhWVSzC6XC5V1VUFFHK4vz9hP9HaZXcoPl+km8yyGn5GG/jbfloQ0FTw0PB8n6FDCEKNjhwgoOMalDpIC89dGFDTaLeF5y5k2fE2KuhwZNasWfr222/15JNP6u9//7vS0tJUWlqqmpoaDR06VFdccUU46mxk165dcrlc6tGjh8/RKgkJCRo0aJA2b96s7777Tueff766d+8uqX56TVlZmdJ8DA0vPPkuKs1xOo4k/qFFABySHO4X+gRqTSp0OCRHeMK0TiaT12gOXyM8uprN6mw2y8RjGxGwt3yvluxYohV7VpxaFl71K5NdmXWlrht2Xbv+I9flqh9hcXqg4Q4/SmtKT20/eUyNo6a1yw5IjClGMeYY72DA8DOSwN/2IEcYBDqSoCXbCRCAtsW9fLi/5cbdTIZJ94y/R78c8ctIlYYgBR2OWK1WLVy4UJ988om2bNmiiooK9enTR2effbZ++MMfevpphFswvU3c/UPS09OVmpqq8vJy7dy5UxMmTGh07K5d9Q0ys7KyQlMoWl12bKySTSZVNGPoWoJh6P917y6zySSny6U61b+AdjTxuc7lkvPk50bbT17D17X8bT/TfrvLqRqHTbXOOtU662Rz1snudMrucsrhcupkl5L6JYrdHzLVf6YXCSLAJCnj5GiOTB+jPdxfZ1gs7X7ZYHQsz217zu8fuxW2Cj3/7fN6YccLWnjuQs8fx63N4XSovLbcZ8jRcLSH+/vSmlLVudpO/7MYU4zS4tPUJa6LUmNStfHoRtmd9jOfeJrkmGR9/bOvFW+JD0OVAODthrNuUE7vHL2440Ut37O8UZh+VdZVmjdsXrsO06NBs14Zmc1m5eTkKCcnJ9T1BMw9CuTw4cMqLi5uNHqkqqpKe/fulST16NFDUn1PgXHjxunDDz/U2rVrG4Uju3btUn5+vsxms8aOHRuBnwKRkGAy6crkZD1fXh70uT9NSdGPOsAUq1pHrY6eOKojJ47oyIm8k5/rPw6fKNCRqqM6Wl0syfAOUQyT92d3qBLsfnkfZzHHKiU2TcmxqUqKTVWnmBQlxSQrMSZZiTGdFG9NUow5Xk6dGtHRkgDpjPvPEGwxI9S3BMNo1MPDVz+PNLNZZt7pRDvz3LbnAhom7XQ5PceFIyCxO+1ewcaZ+naU15a3qaVP4y3x6hLXpf4jvovS4tJ8fx9fvy3JmuQ1MuLuz+7W898+H/TtXpV1FcEIgIgalDpI9024T386908qMZWo0lYpW6VNg1IGReU0zPao3b5tPGrUKHXq1EmVlZV67LHHdMsttzRqyFpZWSmr1arx48d7zpsxY4bWrFmjrVu36q233tL06dNlGIaKioo8q8pMnTpVqamprfJzITyuS03VC+XlQb3INUma10H+P4g1x6pPch/1Se7j9xi7067CqkKv4OT0j6MnjoTkHcY6SSUnP/yJMcWoW2I3dU/s7vcjIz7jjMushYIrkFFBPrY3uT+A0Kbh9oBGG51++6fX0OCcUodDW2qD68je0IpevXReAv/Qo2PaW75X931xX1Dn3PfFfcrpnXPGdwVbozlpKHWydgoo5HB/3dKA4rph1+mFHS8E3+xw2LwW3S4ANFeCNUEDug2QJBUUFNB4tR0xXM1oL7xz5069//77ys/P97nk7WOPPebjrNDbvHmzHnnkEdntdplMJnXt2lVms1kFBQWqq6uT2WzWjTfeqMmTJ3ud9/HHH+upp56Sy+VSWlqaUlJSlJeXJ4fDoQEDBmjRokWKiwv/8iNFRUWe5YURfs+VlWlRUVHAxy/KyNANnTuHsaL2x+F0qLimuD4sOX4qNCmoKvAKUWodzX/RHQyzYVbXhK6+w5Ok7uqR2EOZCZmymqwRqac9qXI69YPvvmvWdLNkk0lfDxhAo1N0WM0drfDjPj/Wxf0vbjfNSQ0ZSo1N9Qo00uLSPN+7Aw/3NJe0uDTFmmMjXmego3jcFo1f1GamOQGIPiaTydO/knCkbbBarcrIyDjjcUGHI7t27dKiRYs0ZMgQ7dixQyNHjlRVVZX27dunzMxMZWVl6ZZbbml24cE6fPiw3nnnHW3fvl0lJSVyuVzq3Lmzhg4dqksuuUQDBgzw+3O8/vrr2r17t2pra5WRkaGJEydq5syZIV3GtymEI5H3XFmZ7isqanIEiUnSPRkZ+iXBSLO4XC6V1Zbp8InDXgGK91Sew6quC7xvUEsYMpSZkNnkCJSuCV0VZ2ml9Zhb0d2Fhc2abnZ9aqruOzlSD2hvbA6bquuqVVVX5fW52l6t6rpqldWW6a4Nd7WbpqMNmQ3zqUCjQcjRMOBoOKojNTZVlnbSe6qp/i9uNDsE0BYQjrQ9YQtH/vKXvyg9PV033nijfvrTn+rBBx/UgAED9P333+vBBx/UTTfdpDFjxjS78GhCONI69tpserG8XMsrKrzeNU82mXRVcrLmpaZqUIQCsmjlcrlUYatocgrPkRNHvJpZhVuXuC4+gxP31J4eiT063HzRvTabcvbvD3q62dp+/XiMICxcLpdqHDX1oYW9ymeIcfp290eVvUrVjjPsr6tuU81Hz6Rhc9KmQg53IJISmyKT0XFHdO0t30uzQwBtHuFI2xNoOBL02wV5eXm69NJLPd+77+z+/ftr9uzZWr58OeEI2rRBMTG6LzNTf8rMVElSkiodDtnKyzXIamWljAgxDEMpsSlKiU3RkLQhfo87bjuugqqC+lEop03lcX+U1ZaFpCb3kPftJdv9HpMSk9LkCJTuSd3Vydqp3SyzOCgmRgszMoKabrYwI4NgJIrVOetOhQ0hCitODz86spY2J412NDsEAIRT0OFIbW2t4uPjZTKZZLFYVFlZ6dnXs2dPHTp0KKQFAuGSYDJpQHKyJKmgtpZUtw1KiknSoJhBTb4TWF1XrYITBU2OQCmqDvzFf1OO2Y7pmO2Ydpbt9HtMojWx6QAlsbs6x3ZuMy943H11mG7W/rlcLtU6agMKIk4PJWrqavyP1Giw3+Zs3GcM3q7MulJD04aGpTkp6tHsEAAQDkGHI126dNGxY/Wd03v16qXNmzfr7LPPllTfqDWpAyx7CqD9iLfEq39Kf/VP6e/3GJvDpqNVRxv1PWkYqhytOhqS5S9P2E9ob/le7S3f6/eYOHOc10o8PRJ7NApQusR3idzw+EMr5PrmH1L36VK3aZKlwfN43XGp4AO5jrwt18ifS51pcthcTpfzjKMmTu9/4W9Kia+Ao7quuk0t4dqWGDIUb4lXvCVeCZaE+s/WBM+2htutZqte/r+Xm9VYOjkmWQ+d/xAhCAAA7VDQ4cjw4cO1Y8cOjR8/Xjk5OfrHP/6hI0eOyGKxaPPmzV5TbgCgLYgxx6h3p97q3am332PqnHUqqi7yPfrk+KlVeezOlvcJqnHUaH/Ffu2v2O/3GKvJqm4J3TzTdXyNQMmMz2zxUsZeq0Ds+1/p+/8nJfaVzAmSo0o6cUBy1sgleY7rqKtA2J12v6HFmcIKz+iKJsKM9tjgM1IshsVvWOHe7vnekqA4S1yT+08PP+LMcUGN1nK5XM1areaqrKsIRgAAaKeCbsh67NgxVVZWqlevXpKkN998U59++qkk6Qc/+IGuvPJKWSzto/N5a6Mha+uiWRKC5XQ5VVJd4nP1Hc+yxicKIvYi2GyY/a7E4x6NkpmQqRiz7x4he8v3KmdFTlCjDUyGSWuvXBvxpoe+GnW2JKzwNe2kPTXqjLQ4c1yTQUQgYUW8Nd5viNHWlttuT4+NaMS/3wDaMp6j2p6wNGR1Op2qqalRWlqaZ9vMmTM1c+bM4CsEgHbGZJiUkZChjIQMjcwY6fMY91LGTfVAOXz8sKrqqlpcj8Pl8FzTH0OGMuIzvKbxuD/e2/9e0NMwnC6nXtzxou6bcJ93LU5HyFcViaZGnS1hMky+gwhz06MqvAKNhsHGaefFWeI69AoovgxKHaSF5y48NaoqAAvPXUgwAgBAOxbUyJG6ujrNnTtXv//971mRJgQYOdK6SHXRWlwulyrtlT5X32n4ccx2rLVL9clkmNSnUx/VOGpo1BmAGFOM/zCimWFFw/0xppg20+C3o3lu23O674v7mgwRTYZJ94y/R78c8csIVhbd+PcbQFvGc1TbE5aRIxaLRSkpKc0uCgBQv5RxckyyktOSlZ2W7fe4E/YTTYYnR04cUWlNaQQrr+d0OZvsl9KeBNOo01/vi6aOibfEy2Jiqml7dcNZNyind45e3PGilu9ZrgpbhWdfckyyrsq6SvOGzWPECAAAHUDQPUeWLFmisrIy3XbbbeGqKWowcqR1keqiI6ipq2m0Es/pH4VVhXIpqKf6NqOtNepE9Kpx1KjEVKJKW6VslTYNShmkBGtCa5cVlfj3G0BbxnNU2xOWkSOSNHDgQL3yyiu6//77NW7cOHXu3LnRH5Zjx44N9rIAgGaIs8Spb3Jf9U3u6/cYu9OuwqrC+saxJ6fybC3aqje/e7Plt39ao87mhBXtqVEnoleCNUEDug2QxB+7AAB0REGHI0888YQkqbS0VNu2bfN5zNKlS1tWFQAgZKwmq3om9VTPpJ5S1/ptVfYqrT201muaQKA6WTtpw082qHNc56hr1AkAAICOKehw5M9//nM46gAARFCCNUFXZl2p5799Puhz5wyeoy7xXcJQFQAAANA6gg5HzjrrrHDUAQCIsOuGXacXdrwQ1HK+JsOkecPmhbEqAAAAIPIYDw0AUWpQ6iAtPHdhUOcsPHchK3MAAACgwwl65Mj999/f5H7DMHTXXXc1uyAAQOTccNYNkqT7vrivyREkJsOke8bfo1+O+GWkSgMAAAAiJuhwpLa2ttHqNJWVlSooKFBycrJn2SIAQPtww1k3KKd3jl7c8aKW71nu1aQ1OSZZV2VdpXnD5jFiBAAAAB2W4XK5XKG40KFDh/Too49q/vz5Gjp0aCgu2eEVFRXJbre3dhlRizXIgcZqHDUqMZWo0lYpW6VNg1IGKcGa0NplAa2OfzPaDu4LAG0Zz1Ftj9VqVUZGxhmPC1nPkV69emn69Ol6+eWXQ3VJAECEJVgTdE7PczSl/xSNzhxNMAIAAICoENKGrJmZmcrLywvlJQEAAAAAAMIqpOHIxo0blZqaGspLAgAAAAAAhFXQDVmfeeaZRtvsdrvy8vJ04MABXXPNNSEpDAAAAAAAIBKCDkc2b97caLUad4OTX/3qV5o0aVLIigMAAAAAAAi3oMORp59+Ohx1AAAAAAAAtIqQ9hwBAAAAAABob4IORz7++GOtWLHC574VK1bok08+aXFRAAAAAAAAkRJ0OLJq1SrFx8f73JeQkKD33nuvxUUBAAAAAABEStDhSEFBgfr06eNzX+/evXXkyJEWFwUAAAAAABApQYcjTqdT1dXVPvdVV1fL4XC0uCgAAAAAAIBICToc6dOnjz777DOf+z777DP17t27xUUBAAAAAABEStBL+U6bNk1PPvmkYmNjNW3aNKWlpam0tFQffvihPv/8c918883hqBMAAAAAACAsgg5HJk2apEOHDumtt97SunXrPNsNw9Dll1+uSZMmhbI+AAAAAACAsAo6HJGka665RlOmTNE333yjiooKJScna9SoUeratWuo6wMAAAAAAAirZoUjktStWzd169YtlLUAAAAAAABEXNANWTdv3qwPPvjA574PP/xQW7ZsaXFRAAAAAAAAkRJ0OJKbm6sTJ0743FdVVaWVK1e2uCgAAAAAAIBICTocyc/P14ABA3zu69+/vw4dOtTiogAAAAAAACIl6HDEbrfL4XD43OdwOFRbW9viogAAAAAAACIl6HCke/fu2rx5s899X3/9tbp3797iogAAAAAAACIl6HAkJydHq1ev1ooVK1RZWSlJqqysVG5urlavXq2cnJyQFwkAAAAAABAuQS/le/HFF2vPnj1avny5li9fLovForq6OknSxIkTdemll4a8SAAAAAAAgHAJOhwxDEO33nqrpk6dqi1btqiiokLJyck6++yzNXz48HDUCAAAAAAAEDZBhyNuI0aM0IgRIxptz8vLU58+fVpUFAAAAAAAQKQ0OxxpqLq6Whs2bNCaNWu0b98+LV26NBSXBQAAAAAACLsWhSM7duzQmjVr9MUXX8hmsyk5OVnTp08PVW0AAAAAAABhF3Q4UlZWpnXr1mnt2rU6evSoZ/vPfvYzXXLJJbJYQjIYBQAAAAAAICICSjKcTqc2bdqkNWvWaOvWrXI6nUpPT9fs2bN1zjnn6I9//KMGDRpEMAIAAAAAANqdgNKMG2+8URUVFbJarTr33HOVk5OjkSNHyjAMVVVVhbtGAAAAAACAsAkoHKmoqJAkDR06VDk5ORo1alRYiwJTmbk9AAAgAElEQVQAAAAAAIiUgMKR3/3ud1q7dq22bt2qb775Rl26dNHkyZOVk5OjxMTEcNcIAAAAAAAQNgGFI+eee67OPfdclZaWat26dVq3bp1yc3O1cuVKDR48ONw1AgAAAAAAhE1QHVTT0tJ0xRVX6IorrtD27du1Zs0affnll5KkRx55RJMmTdIFF1ygXr16haVYAAAAAACAUGv28jIjRozQiBEjVFVVpfXr12vt2rV677339N5772np0qWhrBEAAAAAACBsWrz2bkJCgqZNm6Zp06Zp//79WrNmTSjqAgAAAAAAiAhTKC/Wr18//eIXvwjlJQEAAAAAAMIqpOEIAAAAAABAe0M4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKjWrKV8a2pqtHXrVhUVFclms3ntMwxDs2bNCklxAAAAAAAA4RZ0OLJ371499NBDqqys9HsM4QgAAAAAAGgvgg5HlixZopSUFP3+979X3759ZbVaw1EXAAAAAABARATdc+TAgQP66U9/qsGDBys2NlYmk6nRBwAAAAAAQHsRdJLRqVOncNQBAAAAAADQKoIOR6ZNm6bVq1eHoxYAAAAAAICIC7rniNlsVn5+vv74xz9qzJgxSkpK8tpvGIYuvvjikBUIAAAAAAAQTkGHIy+++KLn6++//97nMYQjAAAAAACgvQg6HHnsscfCUQcAAAAAAECrCDoc6datWzjqAAAAAAAAaBVBhyNuhYWF2r59u44fP65OnTpp+PDhyszMDGVtAAAAAAAAYdescOSFF17Q+++/L5fL5dlmMpl00UUX6brrrgtZcQAAAAAAAOEWdDjy7rvv6r333tPUqVM1efJkde7cWWVlZVq3bp1WrVqljIwMXXLJJeGoFQAAAAAAIOSCDkc++ugjXXjhhbr++us92zIyMjR48GBZLBb961//IhwBAAAAAADthinYE44ePapzzjnH576xY8eqsLCwxUUBAAAAAABEStDhSHx8vIqLi33uKy4uVnx8fIuLAgAAAAAAiJSgw5GRI0dq6dKl2r9/v9f2vLw8LV++XCNHjgxVbQAAAAAAAGEXdM+Ra665RnfddZf++Mc/qk+fPp6GrHl5eUpJSdE111wTjjoBAAAAAADCIuiRI+np6frrX/+qSy+9VCaTSYcOHZLJZNJll12mv/71r0pPTw9HnQAAAAAAAGER9MgRSUpJSdG1114b6loAAAAAAAAiLuiRIwAAAAAAAB1JQCNHnnnmGc2aNUuZmZl65plnmjzWMAzNnz8/JMUBAAAAAACEW0DhyJYtWzRt2jRJ0ubNm2UYRliLAgAAAAAAiJSAwpHFixd7vn766afDVgwAAAAAAECkBd1zpLS0VA6Hw+c+p9Op0tLSFhcFAAAAAAAQKUGHIwsWLND333/vc9/+/fu1YMGCFhcFAAAAAAAQKSFdrcbpdNKPBAAAAAAAtCshC0ccDoe2bt2qTp06heqSAAAAAAAAYRdQQ9YVK1YoNzfX8/3dd9/d6Bin0ylJysnJCVFpAAAAAAAA4RdQODJgwABNmTJFLpdLH330kX7wgx8oJSXF6xir1ao+ffpo0qRJYSkUAAAAAAAgHAIKR8aMGaMxY8ZIkmpra/WTn/xEmZmZYS0MAAAAAAAgEgIKRxq65ZZbwlEHAAAAAABAqwg6HHHLz89Xfn6+bDZbo33nn39+i4oCAAAAAACIlKDDEZvNpv/+7//WN9984/cYwhEAAAAAANBeBL2Ub25uro4cOeJZsea3v/2t7rzzTo0dO1bdu3fXgw8+GPIiAQAAAAAAwiXocGTjxo26/PLLNWzYMElSZmamRo8erTvuuEP9+vXTmjVrQl4kAAAAAABAuAQdjhQVFalHjx4ymepPbdhzZNKkSdq4cWPoqgMAAAAAAAizoMORxMRETyCSnJysgoICzz6n06mamprQVQcAAAAAABBmQYcjvXv31pEjRyRJw4cP1+uvv67du3fru+++04oVK9S3b9+QFwkAAAAAABAuQYcjkydP1okTJyRJV199taqrq3X33Xfrzjvv1NGjR3XttdeGvEgAAAAAAIBwCXop34bL9Hbr1k2PPfaYtm3bJkkaMmSIkpOTQ1cdAAAAAABAmAUdjpwuPj5e48aNC0UtAAAAAAAAERdQOFJaWhrURdPS0ppVDAAAAAAAQKQFFI4sWLAgqIsuXbq0WcUAAAAAAABEWkDhyPz582UYhiTJ4XDojTfekMVi0XnnnafU1FSVl5fr888/l91u16xZs8JaMAAAAAAAQCgFFI5MnTrV8/Vrr72mHj166M4775TJdGqxmzlz5ujBBx9UUVFR6KsEAAAAAAAIk6CX8v3444910UUXeQUjkmQymTRt2jR9/PHHISsOAAAAAAAg3IIORyoqKmS3233us9vtOn78eIuLAgAAAAAAiJSgw5F+/fopNze3UQhSWVmplStXqn///iErDgAAAAAAINwC6jnS0Lx583T//ffr5ptv1llnneVpyLpt2zY5nU79+c9/DkedAAAAAAAAYRF0OJKdna0HHnhAy5cv144dO3T8+HElJSVp1KhRmj17tvr27RuOOgEAAAAAAMIi6HBEkvr06aPbb7891LUAAAAAAABEXNA9RwAAAAAAADqSgEaOrFy5Ujk5OercubNWrlzZ5LGGYWjWrFkhKQ4AAAAAACDcAgpHli5dqpEjR6pz585aunTpGY8nHAEAAAAAAO1FQOHIP//5T5lMJs/XAAAAAAAAHUVA4Yg7GDn9awAAAAAAgPaOpAMAAAAAAES1gEaO3H///QFf0DAM3XXXXc0uCAAAAAAAIJICCkdqa2tlGEa4awlaYWGhfv3rXwd07KJFizRs2DCvbbt379Ybb7yhXbt2qaamRpmZmZo4caJmzJihmJiYcJQMAAAAAADamIDCkb/85S/hrqNZYmJilJ2d7Xd/eXm5jh49KqvVqn79+nntW79+vZ588kk5nU6lpaUpPT1deXl5WrZsmb766istWrRIsbGxYf4JAAAAAABAawsoHGmrUlNTmwxuHn/8cR09elRjx45VQkKCZ3thYaGefvppOZ1OzZ07V9OnT5dhGCoqKtIDDzygffv26eWXX9b1118fiR8DAAAAAAC0ohY1ZD1+/LhKS0sbfbQFNTU1+vLLLyVJkyZN8tr31ltvyW63a9SoUZoxY4ZnylBGRoYWLFggSVq9erXKy8sjWzQAAAAAAIi4Zo0ceeONN7Rq1SodO3bM5/6lS5e2qKhQ+OKLL1RbW6vk5GSNHj3as93lcnlCk5ycnEbnZWdnq2fPnsrPz9emTZt0wQUXRKxmAAAAAAAQeUGHI+vWrVNubq6mT5+u3NxczZw5Uy6XS59++qliY2N12WWXhaPOoK1fv16SNGHCBJnNZs/24uJilZWVSZKGDBni89zs7Gzl5+drz549IQlHSkpKvL43m81KTU2VYRgymVhNubU0/N1zPwD1eFwAvvHYaDu4LwC0ZTxHtT2BLi4TdDjy/vvva9asWbr88suVm5ur8ePHa8CAAbryyiu1cOFCVVdXB11sqJWVlWnbtm2SGk+pOXLkiCTJarWqc+fOPs/PzMyUJBUUFISkHvdUHbf+/fvr4YcfVnp6ekiuj5Zz3+cATuFxAfjGY6Pt4L4A0JbxHNW+BB1lHTlyRFlZWZ70xeFwSJJiY2M1Y8YM/etf/wpthc2wfv16uVwu9ejRQ4MGDfLad+LECUlSQkKC3wQpKSlJUn1PFQAAAAAA0LEFPXLEbDbLMAwZhqH4+HiVlJQoKytLkpScnNwmGrK6p9ScPmpEkux2uyTJYvH/o7v32Wy2kNSzePFir+/d03yKi4tVV1cXkttA8EwmkyfNLSwslNPpbOWKgNbH4wLwjcdG28F9AaAt4zmq7bFYLAHN2gg6HOnWrZunh8bAgQO1Zs0ajRs3TpL00UcfKSMjI9hLhlReXp4OHDggwzD0wx/+sNF+q9UqSU2GEu59MTExIampS5cuPre7XC4eLG2E0+nkvgBOw+MC8I3HRtvBfQGgLeM5qm1wuVwBHRf0tJrRo0fr22+/lSTNnDlT27Zt03/8x3/o+uuv1+eff67p06cHe8mQ+uSTTyRJQ4cO9RnUJCYmSpKqqqr8/pLc02nc02sAAAAAAEDHFfTIkTlz5ni+HjlypO69915t2LBBhmFozJgxGjlyZEgLDIbT6dSGDRsk+Z5SI0ndu3eXVD+9pqysTGlpaY2OKSwslFQ/SgYAAAAAAHRsAYUjFRUVSk5O9rlv8ODBGjx4cEiLaq5vv/1WJSUlslqtGj9+vM9j0tPTlZqaqvLycu3cuVMTJkxodMyuXbskydNLBQAAAAAAdFwBTau58cYb9eijj2rz5s0Bz9dpDe4pNWPHjlVCQoLPYwzD8PRIWbt2baP9u3btUn5+vsxms8aOHRu+YgEAAAAAQJsQUDhy3nnnacuWLXrooYe0YMECvfbaayooKAh3bUGx2WzauHGjJP9TatxmzJghi8WirVu36q233vIEPkVFRZ6VZaZOnarU1NTwFg0AAAAAAFpdQNNqfvOb36iqqkqffvqp1q1bp9dff12vv/66hg0bppycHI0fPz5kK7s018aNG1VdXa3k5GSNHj26yWMzMzN144036qmnntLLL7+sVatWKSUlRXl5eXI4HBowYIDmzp0bocoBAAAAAEBrCrgha0JCgi688EJdeOGFOnTokNasWaNPP/1UTz75pJ5//nlNnDhROTk5GjRoUDjr9Wv9+vWSpAkTJshsNp/x+B/96Efq1q2bXn/9de3evVuHDh1S165dNXHiRM2cObPVwx4AAAAAABAZhqsFTUScTqe+/vprrVmzRlu2bJHD4VDv3r31yCOPhLLGDquoqEh2u721y4haJpPJsyJRQUEBa5AD4nEB+MNjo+3gvgDQlvEc1fZYrVZlZGSc8biAeo74Pdlk0tixYzV//nxddNFFkqSDBw+25JIAAAAAAAARFfC0mtM5nU5t2rRJa9eu1ZYtW+R0OtWnTx9NmTIllPUBAAAAAACEVdDhyMGDB7V27VqtX79eFRUVSkhI0NSpUzVlyhQNGDAgHDUCAAAAAACETUDhiHulmrVr1+q7776TpDa1Ug0AAAAAAEBzBRSOzJ8/X3a7XZ07d9bll1+unJwcT5MZAAAAAACA9iygcGT06NGaMmWKRo8eLZOpRT1cAQAAAAAA2pSAwpH//M//DHcdAAAAAAAArYJhIAAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKIa4QgAAAAAAIhqhCMAAAAAACCqEY4AAAAAAICoRjgCAAAAAACiGuEIAAAAAACIaoQjAAAAAAAgqhGOAAAAAACAqEY4AgAAAAAAohrhCAAAAAAAiGqEIwAAAAAAIKoRjgAAAAAAgKhGOAIAAAAAAKKapbULQGCcTqdqampUV1fX2qV0KFVVVZIkm83WypUAbQePC99cLpfMZrNiYmJktVplGEZrlwQAAIAQIRxpB5xOpyorKxUXF6f4+Hj+IA8hq9UqSbLb7a1cCdB28LjwzeVyeYLq2tpaJSUl8XwMAADQQTCtph2oqalRXFycYmNj+UMcAFqJYRgym81KTEyUxWJRbW1ta5cEAACAECEcaQfq6uoUExPT2mUAAE6Ki4tj2hEAAEAHQjjSTjBiBADaDp6TAQAAOhbCEQAAAAAAENUIRwAAAAAAQFQjHAEAAAAAAFGNcAQAAAAAAEQ1whEAAAAAABDVCEeANuriiy9Wz549tXXr1tYupcMYMWKEevbsqdLS0hZfa+fOnerZs6emTJkSgsoAAAAAtCZLaxcQCk6nU2vWrNH69et16NAh1dTUKCUlRf369VNOTo7OOeecRufs3r1bb7zxhnbt2qWamhplZmZq4sSJmjFjhmJiYlrhp0Bz9OzZM+hzzjvvPK1YsSIM1US3G264QatWrZIkjR8/Xrm5uX6P/fLLL3X55Zd7vl+1apVGjRoV9hoBAAAAwJd2H44cP35cDz74oPbs2SPDMNS9e3dlZGSorKxMmzZtktlsbhSOrF+/Xk8++aScTqfS0tKUnp6uvLw8LVu2TF999ZUWLVqk2NjYVvqJEAxfwVdlZaV27tzpd/+QIUPCXle0++KLL3Tw4EH17t3b5/6mghMAAAAAiLR2HY44nU799a9/1Z49ezRu3Dj9/Oc/V5cuXTz7S0pKdPToUa9zCgsL9fTTT8vpdGru3LmaPn26DMNQUVGRHnjgAe3bt08vv/yyrr/++kj/OGiGN954o9G2zz77TFdddZXf/QivgQMHat++fVq5cqVuvfXWRvttNpvefvttpaWlyel0qry8vBWqBAAAAIBT2nXPkdWrV2vnzp0aPny4fve733kFI5LUpUsXDRs2zGvbW2+9JbvdrlGjRmnGjBkyDEOSlJGRoQULFniuyws2oHmmT5+umJgYrVy50uf+NWvWqLy8XDNnzpTVao1wdQAAAADQWLsOR9577z1J0k9+8hOZTGf+UVwul7788ktJUk5OTqP92dnZ6tmzpxwOhzZt2hTaYtFmFRcX6/7779fkyZM1cOBAZWdna+bMmVq2bJlcLlej40tLS/XSSy9p3rx5mjBhggYOHKghQ4ZoxowZevHFF+V0Ov3els1m0wsvvKArrrhCw4cP14ABAzRhwgTddNNNWrNmjd/zduzYoV/84hcaPny4Bg4cqMsuu0wffvhhkz/Xhx9+qGuvvVYjR45U//79dc455+j3v/+9Dh061OjYhs1FXS6XXnjhBU2bNk1ZWVnKyspq8nZOl5qaqpycHO3du9dnM1n3lJorrriiyes4nU7985//1MyZMzVkyBANHDhQkydP1sMPP6yKigq/533//fe66aabNGLECA0aNEgXXnihXn311TPW7XQ6tXz5cl155ZWe+2bixIm69957Q9LAFQAAAEDb1W6n1Rw5ckT5+flKSkpSdna2vvzyS33++ecqLy9XcnKyzjrrLE2aNMnrneni4mKVlZVJ8t93Ijs7W/n5+dqzZ48uuOCCiPwsaD3ffPONrr76ahUXFys2Nlb9+vVTdXW1vvrqK23atEmfffaZ/va3v3md88477+jOO+9UbGysunbtquzsbJWWlurrr7/WV199pQ0bNuiZZ55pdFslJSW69tprPYFBnz591KdPH+Xn5+vtt9/W7t27fa58snHjRj300EOKiYlRv379dPDgQW3evFm/+MUv9Nxzz+niiy/2Ot7lcukPf/iDXnnlFUn1o6KysrK0f/9+vfLKK3r33Xf12muv6ayzzvL5O7n11luVm5urXr16KSsrq9HUtEDMnj1bH3zwgXJzc70arR47dkwfffSR+vfvrzFjxvg9v66uTjfeeKPef/99SVL//v2VmJionTt36vHHH9fbb7+tZcuWqUePHl7nbd++XVdddZUqKioUHx+vrKwsFRYW6o477tD333/v9/Zqamo0f/58ffTRRzIMQ926dVP37t31/fff69lnn9WqVau0YsUKvz1UAAAAALRv7TYc+e677yTVr1byxBNP6NNPP/Xa/9lnn+mdd97Rn/70J2VkZEiqD1QkyWq1qnPnzj6vm5mZKUkqKCgIWa0lJSVe35vNZqWmpsowjIBGvASiW3Z2s8479pe/qHrOnEbb45ctU8rddzfrmgW7dvnc3mXOHFlPBgP+jomkY8eOad68eSouLtbNN9+s2267TQkJCZLqX2TfeOONWr58uSZMmKA5DX5Ho0aN0iuvvKKJEyd6hW/79u3TrbfeqnfeeUfvvvuuLr30Uq/bu/nmm7V161ZlZWXpf//3fzVixAjPvr179/odOfLAAw/ohhtu0B133KGYmBg5nU4tXLhQ//jHP3T//fc3CkeeeeYZvfLKKxo4cKAeffRRT1Nau92uRx99VE888YRuuukmffzxx7JYvJ8C9u7dq8OHD+vVV1/Vj370I0n1wUGwLrjgAqWkpOjNN9/UwoULPbfz9ttvq7a2VrNnz27y/Kefflrvv/++UlNT9fzzz+vcc8+VJB0+fFi//OUvtXXrVt12221atmyZ55y6ujr9+te/VkVFhaZNm6a//e1vSk5OliS99tpr+sMf/uBzJJAk3X///froo480ZswYPfLII8o++XiqqqrSXXfdpWXLlum3v/0tqxyhkVA9h6Pta3hfc7+3Lu4LAG0Zz1Ftj7uVxpm023DEPQJk79692rVrl6ZMmaLZs2crNTVVO3fu1LPPPqv8/Hw9+uij+q//+i+ZTCadOHFCkpSQkOD3F5SUlCSpfhWcUHH3MnHr37+/Hn74YaWnpwd0flVV1Rl7M5iaWa/F5fJ5bYvL1exr+qvVVFPjuWY4e000fMHf1O288sorOnz4sK666irdc889XvvOPvtsPfXUU7rkkkv03HPP6Wc/+5ln39ixY31eb8iQIXr00Uc1ZcoUvfHGG15L1X766adav369EhMTtWzZskZLEA8dOlRDhw712ub+f3TUqFFatGiR17577rlHK1eu1P79+3Xw4EENGDBAUv3/K0888YRiYmK0ZMkSDR482Ot3cffdd2v79u1au3at1qxZ4wlw3L8zh8Ohe+65x2vUVKD3lfvJ32w2KykpSTNmzNBLL72kDRs2eK7n7kMyZ84cr+taLBbP93a7Xc8995wkaeHChTr//PM9x/Xt21fPPPOMJkyYoA0bNmjbtm2eESirV6/Wnj17lJycrMWLF3sey5J07bXX6quvvvJMr2l4e/n5+XrppZfUpUsXvfTSS54wVZJSUlL0t7/9Td98840+//xz7dy50zPixv07Mwyjw/ZO6ag/V6jExMSoW7durV0GWoH7jRS0Pu4LAG0Zz1HtS7uNsmprayXVv5gbOnSobrrpJmVkZMhqteqss87S7bffLsMw9N133+nrr7+WVP+iS1Kjd8sbcu+z2Wxh/gnQ2t59911J0ty5c33uHzt2rNLT07Vjx45GDXqrq6u1dOlS3XrrrZozZ46mT5+uyy67THfccYck6dtvv/U63j09ZNasWY2CkTPxVV9CQoJndMP+/fs92zds2KDy8nKNGzfOKxhpaNq0aZKkzz//vNE+s9l8xlEdgXKvGOQebZGXl6eNGzdq3Lhx6tevn9/ztm3bpuLiYiUnJ3uu0dCAAQP04x//WJK0bt06z/a1a9dKqp/S0zAYcfv5z3/u8/bef/991dXV6cILL/QKRtwsFoumTp0qqX5EGgAAAICOp92OHGn4jubp0wokqV+/fho+fLi2b9+uLVu2aOzYsZ5z6urq/F7XvS8mJiZktS5evNjre7PZLKm+B0pTtbjZbDZPsOOP08eLwUDUGYbPa1sMo9nX9FerMy7Oc80z/Twt0fB32tTt/N///Z8k6d577/XcJ6erqqqSJB06dEiJiYmS6qd0zZ07VwcOHPB77fLycq/b3nVyGtHo0aMD/tndU0B69erl8xz36kwVFRWe/du3b5ck7d69u9G0noa1SfUjJtznuX9nPXr0UExMTLPuH3cjWofDIbvdrjFjxqh3795atWqVysrKtHTpUrlcLs2aNavR9evq6jzbdu/eLal+lIjJZPJZS1ZWlj744APt2bPHs3/v3r2S6pcS9nVO//79fd6eO8j69NNP/f7O3H1XfP3OXC5XWP9/bg0NR/HAP5vNFtIpmGjbTCaT5x3AwsLCJptvI7y4LwC0ZTxHtT0WiyWgWRvtNhxp+M6wv3fie/bsqe3bt6uoqEiSPC9uq6qq5HK5fE6tcU+n8fXOc3OdvsSwm8vlCtmDJdQ9PKrnzPHZi6QlShr0h2httbW1ntFH7pFFTWnYd+OWW27RgQMHNH78eN16660aPny4UlJSZLFYdOzYMQ0bNqzRi8rKykpJ8vTACIa7D8rp3P//Nuyj4b6dwsJCFRYWBvwznem2msMwDCY628UAACAASURBVM2aNUuPP/64Vq1apddff10xMTGaPn16k+e5p7819QTm3uc+tuHXaWlpPs+Jj49XYmKi1znSqd/ZwYMHdfDgwSZra07/FXRs/METnZxOJ/d9G8F9AaAt4zmqbfDXd/B07TYcabhKhb958e7t7v8hu3fvLqn+3dCysjKfL6LcLyiZR96xxcbGymq1ym63a9u2bX5fUJ/uu+++05YtW5SamqolS5Y0CtEOHz7s8zz3cU0tQRsK7nBj7ty5evjhh8N6W4GYPXu2Hn/8cT3yyCPKz8/XxRdf7LcZsps7xCwuLvZ7jHuf+9iGX/tbdre6urpRMNLwvDvvvFO//vWvm6wNAAAAQMfUbnuO9OvXzxN++Ftq1L3d/cI3PT1dqampkqSdO3f6PMc9/SErKyuk9aLtGTRokCT//y/4cujQIUn1zVd9jS7asWOHz/Pc/T8CGaXSEu7b2dUGVgOS6n/Ho0aNUn5+viTpiiuuOOM57uayBw4c8IzuOZ3753Mf2/Br9/Sa0/nb7n6st5XfGQAAAIDIa7fhSFxcnM4++2xJ0scff9xof3l5ubaeXDbWvWSqYRgaN26cpFPNGxvatWuX8vPzZTab/a5Igo7jkksukSTPyiiBiIuLkyTPVK2GXC5Xo/4ybhdddJEk6a233vI7uiQUzj//fHXq1EmbNm3Sli1bwnY7wZg/f77OP/98TZkyxdPYtCkjRoxQly5dVFFRodzc3Eb79+/f71n2ePLkyZ7t7qWHV65c6XOEyJIlS3ze3oUXXiiz2fz/2bvzuKjK9vHjnxkWARUUAZVxAQZETXMF11TcUjMlv6CpqeUD7pppkqYZUppplpm5RLmVBmhuuZQ+T6mZuIQmKoqhKIjiErIr++8PfjM5zoAMomBc79eL11PnPvdyzhmm51zc93Wzd+9ebRBHCCGEEEIIUbk8s8ERAB8fH5RKJb///rvOrhUZGRl8+eWXZGdnU7t2bTp06KAtGzBgAKamppw+fZqdO3dq1x/dvn1b+2Lbo0cP7QwT8e81evRoHB0d2bdvH9OnT+fvv//WKU9LS2Pr1q189NFH2mPNmjXDysqKS5cu8dVXX2mPZ2ZmEhAQQGxsrMG+OnToQJcuXUhPT2fEiBF6u9nExMQYFaQpSvXq1XnzzTcpKCjgjTfe4L///a/eOefOnSMwMJAzZ848dn8l4e3tTWhoKN9++y1VqlR55PlmZmaMGTMGgPnz53P8+HFt2Y0bN5g0aRJ5eXl07tyZli1bast69uyJq6srqampTJ06VZtLBCAsLIzNmzcbTLzr5OTEa6+9xr1793j11Vc5ceKETnl+fj4nTpzg7bfffmQeFyGEEEIIIcSz6ZnNOQKFLzWjR4/mm2++YcWKFYSFhWFjY8O1a9fIysqievXqTJ8+XWfrXgcHB8aOHcuKFSv47rvv2LNnDzY2NsTFxZGXl4eLi0uRW7uKf5caNWrw3Xff8dprrxESEsLmzZtRq9VUrVqVu3fvEhcXR35+Pp07d9bWsbKyYurUqSxYsIB58+axevVqateuTUxMDPfu3WPhwoUEBAQY7G/58uUMHz6cM2fO0Lt3b5ycnLCxsSEhIYE7d+7g7u6Ov7//Y1/XuHHjuH79OmvWrGHUqFHY2trSsGFDcnJyiI+PJyUlBfhn5kxFNH78eE6dOsVPP/3EK6+8gouLC1ZWVkRHR5OTk4OTkxOfffaZTh1TU1O++OILfH192bNnDwcOHMDNzY1bt25x48YNJkyYwPfff8/du3f1+gsMDOT27dvs2bMHb29v6tSpQ926dcnKyuLKlSvaXYumTZv2VK5fCCGEEEII8XQ908ERKJwSX79+fXbu3MnFixe5evUqNWvWpHXr1rzyyisGE2127dqVOnXqsG3bNi5evMi1a9eoXbs2nTp1YuDAgWW6ja+o2Jo1a8bBgwf56quv2LdvH5cuXSI3N5fatWvTuXNnevTooRdEmDhxIra2tnzzzTdcunSJ+/fv07ZtWyZOnEjLli2LDI7UqlWLHTt28O2337J9+3ZiYmJITEykTp06dOrUiSFDhpTJNSkUCj744AP69u3Lhg0bOHHiBOfOnaNatWrUq1eP/v3789JLL9G6desy6e9JMDExITg4mJCQEEJCQrRBkYYNG9KvXz/Gjx9vcOef559/nj179vDxxx/z+++/Ex0djVqt5q233mL48OF8//33BvszNzcnODiYn376iZCQEP7880/Onj1LjRo1cHNzw8PDg/79+2uTOgshhBBCCCH+XRQFJd3XRpS527dv6235akhqamqptoAVj6ZJ6luS5yBEZSG/FyUj382Vi1Kp1O5kl5iYKFszliN5FkKIiky+oyoeMzMz7O3tH3neM51zRAghhBBCCCGEEOJxSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBECCGEEEIIIYQQlZoER4QQQgghhBBCCFGpSXBEiCdg//79qFQqRo4cWSbtZWRkoFKpcHNzK5P2Krq1a9eiUqmYPXu20XWDgoJQqVSsWrXqCYxMPEldunRBpVIRExNT3kMRQgghhBCVjGl5D0BUTJk5mUTfjSY9J51qZtVwr+mOlZlVeQ9Lj0qlMrpOhw4d2LJlyxMYjXjS7ty5w/r166lVqxavv/56eQ/nsXz33XfcvHmT4cOHU6dOnRLVycjIoFGjRkb31aNHDzZs2GB0PSGEEEIIISoLCY4IHTHJMayPWs+Wv7aQmp2qPW5tbo2Pmw+jmo7CtYZrOY5Ql4eHh96xtLQ0Lly4UGR548aNn/i4qlatilqtxtHRsUzaUyqVqNVqrKwqXoDqSbCxsUGtVmNvb69z/M6dO3z66ae4u7s/88GRjRs3EhkZSc+ePUscHFEqlQY/0ykpKVy8eBGlUkmbNm30yt3d3R97vEIIIYQQQvybSXBEaAWfCSboWBD5Bfl6ZanZqaw5t4Z1UeuY224u/s39y2GE+rZv36537MiRI/j6+hZZ/jR07NiRQ4cOlVl7lpaWZdpeRTdo0CAGDRpU3sOocCwtLQ1+pvfv38/rr7+OhYVFuX3mhRBCCCGEeJZJcEQAhYGRwKOBjzwvvyBfe15FCZAIIYQQQgghhBCPQxKyCmKSYwg6FmRUnaBjQcQkP9tJE/fv34+DgwPDhw8nOzubpUuX0q1bN9RqNd27d9eed/bsWT7++GP69+9Py5YtcXJyonXr1owdO5bTp08X2bahhKwXLlxApVJp29+0aRO9e/dGrVbTvHlzJk2aREJCgl57xSVkbdasGSqViqSkJI4ePcqrr75K48aNadSoEb6+vpw4caLIe3Djxg2mTZtGy5YtUavVeHl5sWrVKvLz8+nbty8qlarIa3zY9OnTUalUhISE6JW1bdsWlUrFa6+9pldmKIGqoYSs/v7+9OjRA4Do6GhUKpX2p6hEtUlJSbz77ru0adMGZ2dnOnfuzJdffkl+vv7sKI09e/bw6quv8txzz+Hi4kKnTp2YO3cut27d0ju3JIlyH3w+8M9nIzIyEoB+/frpXMuuXbuKbKus3Lx5k8DAQF544QXUajWNGzdm0KBBRc46uXPnDuvWreO1116jffv2uLi40LRpU1555RVCQ0MpKCgosq/79+8THBzMwIEDadq0KWq1mk6dOjFp0iR+++23IuudPn2akSNH8txzz+Hq6srAgQM5ePBgsde1a9cuhg0bRrNmzXB2dqZdu3bMmjWLGzdu6J0bERGBSqWif//+5OXlsXr1anr27ImrqystW7Ysth8hhBBCCPHvI8ERwfqo9QaX0hQnvyCfDVH/jgSPubm5DB8+nMWLF5Obm4ubmxuWlpba8pkzZ7Js2TJiY2OpWbMm7u7uZGVlsWvXLgYOHMhPP/1Uqn7nzJnDjBkzSEtLw9nZmfT0dLZt28agQYNITU19dAMP2blzJ4MHDyYqKgpnZ2eUSiVHjhxhyJAhnDp1Su/8q1ev0q9fP0JDQ0lJScHNzY3s7Gw++OADpkyZYnT/7dq1AyA8PFyvH83L6YkTJ8jLy9MpP3bsGADt27cvtn03NzeaNWsGFC4v8fDw0P60bdtW7/y///6b/v37s2nTJuzs7LC3tyc2NpYFCxYwb948g33MmTMHf39/fvvtN6pWrYq7uzuJiYl888039OrVi/Pnz5fgThSvRo0aeHh4ULVqVQCaNm2qcy22traP3UdxTpw4Qffu3QkODub69es4OTlhY2PDsWPHmDhxosEdgrZs2cLs2bMJDw9HqVTSuHFjqlevzvHjx5k2bRrTp0832FdiYiL9+/cnMDCQP/74g5o1a9KoUSNSUlLYtm0bH3/8scF6hw4dwtvbm4iICBo0aIC5uTl//PEHI0aMMBggycvLY/LkyYwdO5aDBw9ibm6Om5sbSUlJbNiwgT59+hAdHV3kPRk3bhxBQUFkZmbi5uamfTZCCCGEEKLykGU1z7g2G9uQnpNe6voFBQVk5GaUqu43574hJDoEhUJRqvrVzKoRMTyiVHXL0qFDh7C3t2fv3r08//zzQOFfuzX8/f1p2rSpzuyA/Px8du3axVtvvcWMGTPo1q0bFhYWJe7z8uXL3Lx5k7CwMDp16gRAQkICQ4cO5dKlS6xZs4apU6cadR3z5s1j7ty5jB49GqVSyf3795k8eTJ79uxh4cKFhIaG6pw/ffp0bt26haenJ1999ZU2+emhQ4fw8/MjOzvbqP47dOgAwNGjR3WOa/69Tp06JCYmcubMGe1f5tPT0zlz5gzVqlWjefPmxbYfEBDAgAED6NGjBw0aNHhkbo3g4GA6duzIzp07sbOzAwoDSOPHj2fNmjWMGTNGZ7ejHTt2sHbtWqpUqcIXX3zBSy+9BEBycjKTJ0/ml19+Ydy4cfz3v//FzMzMiDujy8PDg+3bt9O3b18iIyP55JNPaNGiRanbM8adO3fw8/MjOTmZ6dOnM2HCBO3n9tSpU4wbN45169bxwgsv8PLLL2vrtW3blu+//56OHTtiavrPfzaio6OZOHEioaGhDBgwgG7dumnLCgoKGDNmDOfPn+e5555j2bJlOsmQz58/r/dZ0QgKCmLKlClMmTIFU1NTcnNzeeeddwgJCeHDDz+ka9euOud//vnnbN26lSZNmrBkyRLt/czKymLBggV8/fXXTJw4kf379+t9X0VGRnLlyhV++OEHbYDuwd9/IYQQQghROcjMkWdcek76Y/2UNjCikZGb8Vj9VwR5eXl8+umn2sAIoBPoGDhwoN6yCaVSyYABA3jttddISkoyOllqTk4Os2bN0gZGoHBb4mnTpgHw66+/Gn0d/fr1w8/PD6VSqb2GefPmoVQqCQ8P13nhi4yMJDw8HAsLC1atWqWzK0yXLl2YNWsWOTk5RvVfv359VCoV165d49q1a9rjmpkkEyZMAHSDJ5qZJB4eHpiYmBh9zcWxsLBg+fLl2sAIwIABA+jatSv5+fkcOHBA5/zly5cDMHbsWG1gBApneixfvpzq1asTExPD3r17y3ScT9PXX3/NnTt3GDlyJNOmTdP5nLdq1YrFixcD6CxxgsLgSJcuXXQCI1C4C85HH30EwNatW3XK9u/fT0REBDVq1GDjxo16u0Q1adKEN954w+A4O3TowLRp07T9mZqaMnfuXCwtLYmKiuLmzZvac1NSUli5ciVWVlasWbNGJ9BUpUoV5s2bh6enJ+fPnze4jCcvL48PPvhAZ+aSMYFOIYQQQgjx7yDBEVHpOTg46P0l+mFXr17l888/x9/fHx8fH7y9vfH29mb//v0AnDt3zqg+TUxMGDx4sN5xzYtdXFycUe0BDB06VO+Yo6MjDg4O5OXl6QQsNMEcLy8vateurVfPx8enVMEKzdKaBwMgx44do27duvj6+moDNRqa8zT1ylLv3r0NLlExdI/v3LlDVFQUgMEXdhsbG+0OSM/yrkGawM6wYcMMlr/wwgtYWVlx6tQpvdkTmZmZhISEMHXqVIYOHcorr7yCt7e3domS5v5p7Nu3Dyj8LD28JfOjGPos29jY4OzsDOg+uwMHDpCZmUmnTp1o0KCBwfZ69eoF6C/5gsJASP/+/Y0anxBCCCGE+PeRZTXPuGpm1R6rfl5+Hvfy7pW6vqWJJSbK0v3F/3HHXlaKS6YJsGHDBubOnVvsTIrk5GSj+nR0dMTc3FzvuGaWQ0aG8TN6nJycDB63s7MjMTGRzMxM7bHY2Fig8K/3hlSvXp169epx9epVo8bQvn17tm7dytGjR/Hx8SEhIYG4uDgGDRqEtbU1TZs25fjx4+Tn56NUKrXBkUflGymN4u4H6N7jy5cvA4WzRBwcHAzWa9Sokc65z5qcnBwuXboEwOzZs7UzjB6Wn59Pbm4ut2/fpk6dOkBhIuERI0Zw/fr1Itt/+Hfgr7/+AqB169ZGj9WYZ3fhwgUAzpw5g7e3t8F6f//9N1CYA8VQX4+zTEoIIYQQQvw7SHDkGfe4OTsyczJps6kNqdnGJwC1Nrfm5PCTWJpaPvrkCszKyqrIsvPnzzN79mzy8/OZMmUKL7/8Mg0bNsTKygqFQkFwcDCBgYHk5uaWSZ+aF9bidv8oizY1gZLiEk+WJimlJsih+Qv9w8GPdu3acfbsWaKiolCr1URGRmJpaflEdgcx5n5oXrYfXILzMM3sh/T0irEczFhpaWnaa46IePT3hmbmSEFBARMmTOD69et06dKFyZMn07hxY6ytrTE1NeX69et4eHjo/Q5o7pONjY3RYzXm2aWlpQGFgQ9DwQ9D1/SgB5MvCyGEEEKIykuCI5WclZkVPm4+rDm3xui6vm6+z3xg5FF27NhBfn4+w4YN45133tErL+4v6RWZ5uXzwdkkDyvN7BW1Wo2DgwNXrlwhMTFRLzjSoUMHvvnmG8LDw7l79y7Z2dl07ty53P9yrwkE3blzp8hzbt++DUC1av/MeNIk9ywqmFVQUMC9e6WfmVWWHgx2Xbx4sdjgl+Z55OTkcO7cOaKjo6lduzZr1qzRCyYU9TugaT8lJeVxh14sTT9jx45l7ty5T7QvIYQQQgjx7yU5RwSjmo5CqTDuo6BUKBnZdOQTGlHFocnTYWirWNDPs/CscHFxAShya9r09HSdHCXG0OQPOXbsGEePHsXBwQG1Wq0tUygUhIeHl3gL3weVdmekR9Hcj+TkZG7dumXwnIsXL+qcC4X5KhQKBffu3TMYaEpMTCxy55MndS1FqVKlCg0bNgT+WYpSEvHx8QA899xzBmdZFPU74O7uDsDJkyeNHapRNMviituqVwghhBBCiEeR4IjAtYYrc9sZ9xfXue3m4lrD9QmNqOLQ7FqhmTXwoMjISA4fPvy0h1QmunTpAhTuimPo2rZs2UJeXl6p2tYEO3bs2MHly5d1gh+2trY0atSIY8eOceTIEZ3zS0LzPMp6q1U7Ozuee+45ANauXatXnpqayubNmwF0kvcqlUrq168PwOnTp/Xqff/990X2+aSupTh9+/YFCnetKSnNOA3NqsnLy+Orr74yWO/FF18ECj9LmpwfT4KXlxcWFhb89ttvEiARQgghhBClJsERAYB/c38C2wc+cgaJUqFkXod5+Df3f0ojK18eHh5A4cukZuYAFP6VesKECc/slp/NmzenQ4cO3Lt3j3Hjxum8+B4+fJiPPvqo1EtdNMEOzW4lDwc/2rdvT3JyMsePH6dKlSq0atWqxG3XrVsXMzMzrl27pp3RUFYmTpwIwOrVq3W2601OTmbSpEmkpaXh6upKnz59dOp5eXkBsGDBApKSkrTH9+7dy8qVK4vc9Uezs4qhHVSelHHjxmFnZ8fOnTuZPXs2d+/e1SlPSUkhLCyMRYsWaY+1bNkSc3NzIiMj2bhxo/Z4eno6U6dO5caNGwb76tGjB23btiU5OZnhw4fr/P5A4ewVQ4EoY9WqVYvx48eTl5fHa6+9prebUEFBAZGRkcyePZuYmJjH7k8IIYQQQvw7Sc4RoeXf3B+v+l5siNrA5r826yRptTa3xtfNl5FNR1aKGSMa3t7efP3110RFRdGrVy/t8pCLFy+iUqkYP348n332WTmPsnSWLFmCt7c3R48exdPTE3d3d9LS0oiNjcXb25vLly8TGRlp9Ja+7u7u1KxZU/vi3aFDB53y9u3bs379egoKCmjVqpVRASZzc3P69OnDjz/+iJeXF+7u7lhaWmJhYcF3331n1DgfNnDgQE6cOMHatWvx8/Ojfv362NraEh0dzf3797Gzs2PVqlV6QaNJkyaxc+dOTp48iYeHB66uriQlJXH9+nUCAgIIDg7WC0IADBgwgM2bN7N48WK2bdumTfg6ffp0vXtWVuzt7Vm3bh1vvPEG69at47vvvsPV1RVLS0vu3r3L1atXKSgo0AkA1axZk/Hjx/P5558TEBDA0qVLsbOz46+//iInJ4f58+cbzMejUChYtWoVw4cP58yZM3h5eeHs7Ez16tW5du0aSUlJtGrVyuDWycaaNm0aiYmJfP/99wwdOhQ7Ozvq169PdnY2cXFx2qSthrYIFkIIIYQQAmTmiHiIaw1XgjoGETEsgt3euwntF8pu791EDIsgqGNQpQqMQGGehrCwMEaMGIGtrS2XL18mPT2dESNGsGfPHmrVqlXeQyy1hg0bsmfPHgYPHkz16tWJjo7GxMSE2bNns2zZshLtaGOIQqHQ5h2pVauWdgtcjQdnkmjOM8bHH3/MyJEjsbW15ezZszr5Sx7Xhx9+yFdffUWnTp1ITU3l/PnzODg4MHr0aPbt22dw62NHR0e2b99Onz59MDc3JyYmBnt7e1asWMGbb75ZZF/du3fn008/5fnnnychIYHw8HDCw8Of6BIUgFatWvHLL7/w1ltv0bhxY+Lj47W5Z7p27cr8+fNZvHixTp2AgADmz59Po0aNuHPnDvHx8XTo0IEtW7bQu3fvIvuqW7cuu3fvZs6cObRo0YLbt2/z119/YW1tzaBBg5g1a1aZXJNSqeSTTz5h06ZN9OvXDxMTE86ePUtiYiJOTk6MGjWK0NDQIreuFkIIIYQQQlFQmj1DRZm4ffs2OTk5jzwvNTUVa2vrpzCiyufBXTnEP7KysmjSpAm5ublcvHjxmV0+JEpHfi9KRr6bKxelUkmdOnWAwmTL+fn55TyiykuehRCiIpPvqIrHzMxMO0u7ODJzRAihZ/v27WRlZfH8889LYEQIIYQQQgjxryfBESEqqfj4eIKDg0lJSdE5/vPPPxMYGAjAiBEjymFkQgghhBBCCPF0SUJWISqpjIwMAgMDCQoKwtHRETs7OxISErRb+/bv35/BgweX8yiFEEIIIYQQ4smT4IgQlZRKpeLNN9/k4MGDxMfHc+7cOaysrGjfvj2DBw/G19cXhUJR3sMUQgghhBBCiCdOgiNCVFLVq1cnICCAgICA8h6KEEIIIYQQQpQryTkihBBCCCGEEEKISk2CI0IIIYQQQgghhKjUJDgihBBCCCGEEEKISk2CI0IIIYQQQgghhKjUJDgihBBCCCGEEEKISk2CI0IIIYQQQgghhKjUJDgihBBCCCGEEEKISk2CI0IIIYQQQgghhKjUJDgihBBCCCGEEEKISk2CI0IIIYQQQgghhKjUJDgiKjVvb28cHBw4cuRIeQ+lWO3atUOlUhEfH1/eQxEVnL+/PyqVil27dpVJe2vXrkWlUjF79uwyaU8IIYQQQoiKyLS8ByAqpsz8fKKzskgvKKCaQoF7lSpYKSt2LC0hIYHg4GAOHTpEXFwcBQUF2NraUrduXTw8PHjhhRfo1q1beQ+zTP3000+cO3eOF198kWbNmpX3cCqN0NBQpk2bZnS9Tz/9lCFDhjyBEQkhhBBCCCEehwRHhI6Y7GzWJyezJTWV1Px87XFrpRIfa2tG1aiBq7l5OY7QsMOHD/Of//yH9PR0TExMcHR0xM7Ojrt373Ly5EkiIiIIDQ3l7NmzOvVUKhWurq5YWlqW08gfz08//cTmzZupV6+eBEeeInt7ezw8PPSOx8bGcufOHezs7HB2djZY70mrW7cuarWa6tWrl0l7NjY2qNXqpzJ2IYQQQgghyosER4RW8N27BN2+Tb6BstT8fNYkJ7MuOZm59vb416z51MdXlLS0NMaPH096ejo9evRgwYIF1KtXT1uekpLCzz//zI8//qhX98svvwQgJyfnqY1XPPu6d+9O9+7d9Y5PnTqVzZs34+XlxdKlS8thZBAUFFSm7Q0aNIhBgwaVaZtCCCGEEEJUNBIcEUBhYCTw9u1HnpcP2vMqSoDkl19+ISkpierVq7N69Wq9WSA2NjYMHjyYwYMHl9MIhRBCCCGEEEJUZBU7iYR4KmKyswkqQWDkQUG3bxOTnf2ERmScq1evAuDi4mL08piiErJOnToVlUpFaGgo165dY/LkybRo0QI3NzdefvllDh06pD33/Pnz+Pv78/zzz6NWqxk0aBARERF6fcXHx6NSqWjXrl2R41GpVKhUqkeOW9PW5s2bAZg2bZq2rkqlYsmSJdpzL1y4wCeffMLLL79Mq1atcHJyolWrVvj5+XHixAmD7YeGhqJSqZg6dSpZWVksWbKETp064eLiQtu2bQkMDCQzM7PI8V2/fp333nuPzp07o1aradKkCT4+PsUmCc3JyWHNmjW89NJLuLu74+rqSs+ePfn888+5d++e3vlHjhxBpVLh4+NT7D0ydL8vXLjApEmTaNu2LU5OTjRp0oROnToxceJEfv311yLHWFYeTJoaExPDpEmTaNWqFfXr12fVqlVA4f3YvXs3U6ZMoVu3btp70r17dxYuXEhKSsoj2yKGkgAAIABJREFU235QUFAQKpWKVatWkZSUxLvvvkubNm1wdnamc+fOfPnll+Tn688bKyoh6/79+1GpVIwcOZK8vDxWrlxJ165dcXFxoVWrVsycOZPk5OQi78H//vc/Bg0aRKNGjWjatCnDhg3j+PHjXLhwAZVKZXBmjhBCCCGEEE+KzBwRrE9ONriUpjj5wIbkZIIcHJ7EkIyiya0QGxtLSkoKNjY2ZdZ2fHw8ffv25f79+7i6unLt2jVOnjzJiBEj2LhxI+bm5gwfPhwzMzMaNmzIlStXOHbsGEOGDGH37t24u7uX2VgeVKVKFTw8PLQ5LpydnbGzs9OWPxhgef/99zl8+DA2NjY4ODhQu3ZtEhIS2Lt3L/v27ePzzz/nlVdeMdhPbm4uw4YN49ixYzRq1Ih69eoRGxtLcHAw0dHRfP/993p1wsPDGT16NKmpqVhYWODs7ExKSgrh4eGEh4czduxY5s6dq1Pn3r17jBo1it9//x0ANzc3TE1NiY6O5vz58+zevZuQkBBsbW0f+96dOnUKHx8f7t+/j7W1NW5ubuTn53P9+nW2b9/OvXv38PLyeux+SiIqKopp06aRl5dHo0aNqFatmrbs6tWrjBkzBhMTE+zt7XFxcSEjI4PY2Fi++OILdu/ezY8//kiNGjWM6vPvv/+mf//+XL9+HXd3d0xMTIiNjWXBggXcunWLefPmGdVeQUEB/v7+/Pzzz7i6utKgQQMuX77Mt99+S2RkJDt37sTUVPc/NevXr+fdd98FwM7Ojnr16nH69Gl8fX155513jOpfCCGEEEKIsiDBkWdcm0uXSC8oKHX9goICMkpZ/5vkZEJSUlAoFKWqX02hIEKtLlXdB3Xp0gWlUklqaiqvvvoqkyZN4oUXXsDa2vqx216+fDn9+vVj0aJFVKtWjfz8fObMmcP69euZN28eaWlpvPbaa8yaNQtzc3OysrIYO3Ys+/fv57PPPtPOAihrDg4ObN++XZvjYvLkyUXugjJixAgCAwNp0qSJ9lhBQQH79u1j8uTJzJo1i169eum8mGvs2rULZ2dnDh48iPr/P6uIiAiGDx/OoUOH+PXXX3UCCYmJifj5+ZGWlsbMmTMZM2YMVapUAeDEiROMGzeO1atX06FDB3r16qWtt3jxYn7//Xfq1KnDunXraN68OVAY8Hr99dc5d+4c7777bpncz6VLl3L//n0mT57MtGnTMH8gwfDp06e5fPnyY/dRUsuXL+ell15i0aJF2iDf/fv3AahZsybLli2jZ8+eOgG/pKQk5s+fT0hICJ988gkffvihUX0GBwfTsWNHdu7cqQ2o7dy5k/Hjx7NmzRrGjBmDk5NTidv77bffqF27Nvv27eO5554DCmfmDBkyhNOnT7Njxw7+7//+T3t+TEwMgYGBAMycOZOJEyeiVCrJzs7mww8/ZNGiRUZdjxBCCCGEEGVBltU849ILCkjPzy/1T2kDIxoZj9P/Y/atoVarmTFjBgCRkZGMGTOGpk2b0qVLF9566y127NhBVlZWqdq2tbVlyZIl2sCBUqlk5syZWFhYEBUVhY2NDXPnztW+YFepUoU5c+YAcODAgce/uDLQv39/ncAIgEKh4MUXX9QGMvbv32+wbm5uLkuXLtUGRgDatGnD0KFDAfSWoKxevZrk5GT8/PyYPHmyNjAC4OHhwcKFC4HCF3SNtLQ0NmzYAMD8+fO1gREAZ2dnPv/8c6AwUHPlyhVjL19PbGwsABMnTtQJjAC0aNGiyFk0T4KjoyNLly7V2VnGwsICgFq1avF///d/ejOhbG1tWbx4MTVq1GDbtm1G92lhYcHy5ct1ZhoNGDCArl27kp+fb/TnNicnh0WLFmkDIwCNGzfGz88P0P+MrFu3juzsbPr06cPkyZNR/v8tws3NzZk3bx5NmzY1+pqEEEIIIYR4XDJzRPwrTJkyhTZt2rBq1SoOHz5MdnY2ly5d4tKlS4SFhaFSqVi6dCkdO3Y0qt2BAwfq5TGxtramfv36/PXXXwwZMkRv5oyrqysWFhakpaWRlJRUJktBHldCQgLbtm3jzJkzJCUlaXfnuXPnDlC4vMNQUOC5556jRYsWesdbtmwJ/JPvRWPv3r0ADBs2zOA4vLy8MDc3JyIigtzcXExNTTl+/Dj37t1DpVLx4osvGuyrTZs2REREcOjQIaNmNRji6OjIpUuX+PHHH4sc59MyYMAAnQCSIQcOHOCXX34hNjaWjIwMbV6Q7OxsMjMzSUhIKFGeGo3evXsb/Ey2aNGCgwcPEhcXZ9Q1ODo60rVrV4Ptgf5nRJOvx9BMJ4VCweDBgzl9+rRRYxBCCCGEEOJxSXDkGVdNoQBl6ScA5RUUcO8xZnBYKhSYPMaymrLUqVMnOnXqxL1794iMjOTUqVP873//Izw8nISEBEaMGKHNi1BSDRs2NHi8Vq1a/PXXX8WWJyQkkJmZWe7BkbCwMGbNmqVdrmFIUYkzi7s+gIyMDO2xjIwM4uPjAQgICCh2TPfv3+fu3bvY29trl7G4uroWuUTL3d2diIiIMlny4ufnx2+//caMGTNYvXo1Xbt2xdPTk44dOz71Z1XcZ/HevXv4+fk9ciZHcnKyUcGRooJLmpkkDz7TkijqM6Jp7+HEvZrZPw/PZtIo6rgQQgghhBBPkgRHnnGPm7MjMz+fNpcvk2pgl4pHsVYqOeniguVjBGeeBEtLS9q1a0e7du0YN24cx48fZ/jw4WRmZrJ69WoWL15sVFuGaF7iH1VeUEZLh0rrypUrBAQEkJOTw9ixYxk0aBBOTk5UrVoVhULBpk2bmDFjhnYmycOsrKwMHlcaeOapqanafy5qF5wHaYI1mpdxTcDFkNK+uBvSs2dPNmzYwLJlyzh58iQxMTF88803mJqa0qdPHwIDA6lbt+5j91MSRd1fgCVLlnDgwAEcHR2ZPXs2Hh4e2Nvba5cC9erVi6ioKHJzc8ukT80zNfYza0x79+/fJy8vD4CqVasarFfUcSGEEEIIIZ4kCY5UclZKJT7W1qwpZsvNovhaW1e4wIghnp6ejBo1ipUrV3Lq1KlyG8ejAibFbY1bWj/++CM5OTkMHDhQb4cYKNxyt6w8+FJ75coVzMzMjKr3999/F3mOZvnPg308zv3s0aMHPXr04O7duxw/fpzDhw+zfft2bV6TXbt2lXj8T4omn8iKFSvw8PDQKy/LZ/e0WFhYYGJiQl5eXpGzqsoiACaEEEIIIYSxKv6brXjiRtWoYfQHQQmMNHIL0fLUoEEDgCJnSDwNmr+wFxUE0CQKNcajdgrSLHNp27atwfKoqCij+yyKtbU1derUASA6OrrE9VxcXAD466+/igx0aNrTnAuPvp8lSd5as2ZNXnzxRT744AN++eUXrK2tOXv2bLnnvMjJySExMRETExNatWqlV379+vUil0JVdM7OzkDRn73z588/zeEIIYQQQggBSHBEAK7m5sy1tzeqzlx7e1wf2umjvCQlJT1yKcAff/wB/PNiVh5q1qyJtbU19+/fNxg8+P77741uU7OzSVH5RDTlt2/f1iuLiYkpcpea0urbty8AX3/9dYnreHp6YmlpyfXr1/n555/1yk+fPk1ERAQKhYIuXbpoj2sCXnFxcSQlJenV27Rpk1Fjt7e3p379+gDcvHnTqLplzdTUFDMzM/Ly8gxe28qVK8thVGVD8ww3b95ssHzLli1PczhCCCGEEEIAEhwR/59/zZoE2ts/8gOhBObZ2+Nfs+bTGFaJ/PDDD/Tq1YuNGzfqvUimpKSwePFitm7dChjeIeNpUSgU2l095s2bp7N8ICwsjJCQEKPb1CTDPHbsmMEAkaenJwAbNmzg7Nmz2uOXLl1i7NixelvZPq4JEyZQo0YNNm/eTGBgICkpKTrld+/eJSQkhKVLl2qPVa9enZEjRwIwe/ZsnXFeuXKFqVOnAvDyyy/rJBOtWbMmrVq1Iisri3nz5mlnBeXl5bF8+XIOHjxocIzjx4/nv//9L9nZ2TrHd+3axYULF1AoFDRr1qz0N6EMKBQK7Wyf999/n3v37gGFS4i+/fZb1q9frw18PWtef/11zM3N2bNnDytWrNDZfef999/Xef5CCCGEEEI8LZJzRGj516yJV9WqbEhOZnNqqk6SVmulEl9ra0bWqFFhZoxoKBQKzp8/T0BAAAEBATRo0IBatWqRnJxMQkKC9iV43Lhx2pkN5eXtt9/ml19+4eDBg7Rs2RK1Ws2tW7e4efMmH330EbNmzTKqvT59+vDxxx+zY8cOIiIiUKlUKJVKfH19GTJkCH369KF169acPHmSfv364eLigomJCdHR0Tg4ODBlyhQWLVpUZtfn6OjIunXrGD16NMHBwaxbt067tXFSUhJxcXEUFBQwYMAAnXozZszgzJkzHDlyhBdffJFGjRphampKdHQ0eXl5NG3alPnz5+v19+677zJ06FC2bNnC/v37cXJyIi4ujrS0NAIDA5kzZ45enQMHDrBz506qVKmCs7MzFhYW3LhxQztbZOrUqUXuwPI0BQQEMHjwYHbu3MmBAwdwcnLixo0b3L59m5EjR/Lnn38SGRlZ3sM0mlqt5v3332f27NnMnz+fr776CpVKxZUrV0hPT+edd95h/vz5BpP+CiGEEEII8aTI//sUOlzNzQlycCDCxYXdDRoQWq8euxs0IMLFhSAHhwoXGAEYNWoUYWFhjB8/nrZt25KXl8e5c+dITExEpVLh4+PDtm3beO+998p7qLi6urJ161a8vLxQKpVcunSJ+vXrs27dOu3sCWM4OTmxbt06OnToQEpKCsePHyc8PJxr164BhcszNm3axOjRo7G3t+fKlSukpKQwdOhQ9u7dq80RUpY8PDw4cOAAU6ZMwc3Njbi4OM6fP49CocDLy4sFCxYQFBSkU8fS0pJNmzYRFBREixYtuHbtGpcvX6ZRo0YEBASwc+dOg8k7O3bsyMaNG/H09CQ7O5vLly/TvHlztmzZQs+ePQ2Ob+nSpQwfPhxnZ2cSExM5f/48lpaW9O3blx9++IEZM2aU+T0pDU9PT8LCwujYsSM5OTlcunSJunXrsnDhQj766KPyHt5jef3111m/fj2enp5kZGRw+fJlmjVrRmhoKO3btwegWrVq5TxKIYQQQghRmSgKynuv0Urs9u3bJUoQmpqairW19VMYUeWj2ZGkPBO1ClHRlOfvRVhYGG+99RaDBg3iiy++eOr9G0O+mysXpVKpDSgnJiZql4SJp0+ehRCiIpPvqIrHzMwM+xLk2JSZI0IIISqMsLAwoOgdloQQQgghhHgSJDgihBDiqdq+fTuHDh3S+UtKeno6s2fPJjw8HBsbGwYOHFiOIxRCCCGEEJWNJGQVQgjxVEVGRrJ69WosLCxwcnLCxMSEmJgYsrKyMDMzY8mSJdSoUaO8hymEEEIIISoRCY4IIYR4qvr3709SUhInTpzg2rVrZGVlYWdnR4cOHRg7dmy5b6UshBBCCCEqHwmOCCGEeKpat25N69aty3sYQgghhBBCaEnOESGEEEIIIYQQQlRqEhwRQgghhBBCCCFEpSbBESGEEEIIIYQQQlRqEhwRQgghhBBCCCFEpSbBESGEEEIIIYQQQlRqEhwRQgghhBBCCCFEpSbBESGEEEIIIYQQQlRqEhwRQgghhBBCCCFEpSbBESGEEEIIIYQQQlRqEhwRQgghhBBCCCFEpSbBESGE1pIlS1CpVCxZsqS8h1Lh7d+/H5VKxciRI8ukvYyMDFQqFW5ubmXSnhBCCCGEEKLkTMt7AKJiysxUEB1tSnq6gmrVCnB3z8XKqqC8h1WshIQEgoODOXToEHFxcRQUFGBra0vdunXx8PDghRdeoFu3bjp1QkJCiIuLw8fHh/r165fPwEWxVCqV0XU6dOjAli1bnsBohBBCCCGEEP9GEhwROmJiTFm/3ootW6xITf1nYpG1dT4+PpmMGpWJq2tuOY7QsMOHD/Of//yH9PR0TExMcHR0xM7Ojrt373Ly5EkiIiIIDQ3l7NmzOvVCQkI4cuQI7dq1k+AIYGtri1qtxtbWtryHouXh4aF3LC0tjQsXLhRZ3rhx4yc+rqpVq6JWq3F0dCyT9pRKJWq1GisrqzJpTwghhBBCCFFyioKCgoo9HeBf7Pbt2+Tk5DzyvNTUVKytrZ/4eIKDqxIUZE1+vqLIc5TKAubOTcXfP+OJj6ek0tLS6NixI0lJSfTo0YMFCxZQr149bXlKSgo///wzP/74I99++61OXV9fX44cOcLmzZvp2LHj0x66KKUjR47g6+sLFM4YEmXLzMwMoETfT5XZ0/puFhWDUqmkTp06ACQmJpKfn1/OI6q85FkIISoy+Y6qeMzMzLC3t3/keTJzRACFgZHAQJtHnpefr9CeV1ECJL/88gtJSUlUr16d1atXY2lpqVNuY2PD4MGDGTx4cDmNUAghhBBCCCFERSYJWQUxMaYEBRn318+gIGtiYipGbO3q1asAuLi46AVGinLkyBFUKhVHjhwBCmeQqFQq7U9oaKj23IiICD788EP69u3L888/j7OzM23btmXy5MlER0cX2UdBQQEbNmygZ8+eqNVqWrRowcSJE7l69SqhoaGoVCqmTp1qsO7169d577336Ny5M2q1miZNmuDj48OuXbv0zn3jjTdQqVTs27dP53hubi6NGjVCpVIxefJkvXpTp07Vu9biErLu27ePYcOG0axZMxo2bEjz5s3p2bMnc+bM4a+//jJ4HQcOHOD111+nRYsWODs706ZNG9566y2uXLlS5H0rSw8mTc3Ozmbp0qV069YNtVpN9+7dteedPXuWjz/+mP79+9OyZUucnJxo3bo1Y8eO5fTp049s+0EXLlxApVJp29+0aRO9e/dGrVbTvHlzJk2aZHC2S3EJWZs1a4ZKpSIpKYmjR4/y6quv0rhxYxo1aoSvry8nTpwo8h7cuHGDadOm0bJlS9RqNV5eXqxatYr8/Hz69u2LSqUq8hqFEEIIIYSoLCQ4Ili/3qrYpTSG5Ocr2LChYuRGqF69OgCxsbGkpKSUqI61tTUeHh7auo0bN8bDw0P78+C0qylTprBy5Uri4+Oxt7fH1dWVjIwMtm7dSr9+/bQBloe9/fbbzJo1i/Pnz+Pg4ICjoyM//fQT/fr10wZ0DAkPD6dHjx6sWbOGGzdu4OzsTLVq1QgPD2fs2LEEBQXpnN+uXTttvQedOXOGjIzC2T1Hjx7V6+fYsWNAYfLSR1m7di1vvPEGBw8exMzMjOeeew4bGxtiY2NZu3YtBw4c0Kszd+5chg8fzv79+wFo1KgRGRkZhIWF0adPn2Jf6MtaXl4ew4cPZ/HixeTm5uLm5qYTSJs5cybLli0jNjaWmjVr4u7uTlZWFrt27WLgwIH89NNPpep3zpw5zJgxg7S0NJydnUlPT2fbtm0MGjSI1NRUo9vbuXMngwcPJioqCmdnZ5RKJUeOHGHIkCGcOnVK7/yrV6/Sr18/QkNDSUlJwc3NjezsbD744AOmTJlSqmsSQgghhBDi36hi/OlflFqbNrVJTzcusPGgggLIyChd/W++qUpIiBWKUnZfrVoBERE3S1f5AV26dEGpVJKamsqrr77KpEmTeOGFF4rNBdCsWTO2b9+uzTnywQcfFJlzZOrUqXh6etKwYUPtsdzcXDZv3szMmTN5++23OXz4MErlP7HGXbt2ERISQpUqVVi5ciUvvvgiAHfv3mXixImsWLHCYF+JiYn4+fmRlpbGzJkzGTNmDFWqVAHgxIkTjBs3jtWrV9OhQwd69eoF/BPceDgAovn3OnXqcP36deLi4mjQoAFQmKcjLi4OR0dH7bGi5Obm8sknn2Bqasrq1avp06ePTtmvv/6qDTJpfPvtt3zzzTc0aNCAJUuWaO9tXl4ey5cvZ9GiRYwfP57Dhw9jYWFRbP9l4bfffsPe3p69e/fy/PPPA3D//n1tub+/P02bNtWZtZGfn8+uXbt46623mDFjBt26dTNqrJcvX+bmzZuEhYXRqVMnoPC+Dx06lEuXLrFmzZoiZw4VZd68ecydO5fRo0ejVCq5f/8+kydPZs+ePSxcuFBnFhDA9OnTuXXrFp6ennz11VfaoN+hQ4fw8/MjOzvbqP6FEEIIIYT4t5KZI8+49HQF6enKUv9kZCiB0gZXFGRklL7vxwnqPEitVjNjxgwAIiMjGTNmDE2bNqVLly689dZb7Nixg6ysrFK37+vrqxMYATA1NWXo0KEMGDCAq1evEhERoVO+evVqAN58801tYASgZs2arFixosgdSVavXk1ycjJ+fn5MnjxZGxiBwl1ZFi5cCEBwcLD2eLNmzahWrRrnzp0jLS1Nezw8PBylUsnYsWO1/66hCZy0b9/+kdeflJREcnIyjRs31gmMaO5Dr169dNrJzs7m008/xcTEhODgYJ2gk4mJCW+++Sb9+vXjxo0bBpcJPQl5eXl8+umn2sAIoBPoGDhwoN5yFqVSyYABA3jttddISkri0KFDRvWZk5PDrFmztIERKNyWeNq0aQD8+uuvRl9Hv3798PPz0wbiLCwsmDdvHkqlkvDwcJ2AT2RkJOHh4VhYWLBq1Sqd2VBdunRh1qxZknBVCCGEEEKI/0+CI+JfYcqUKYSFhdG9e3fMzc0pKCjg0qVLhIWFMWHCBF544YUil7+URExMDJ988gl+fn74+Pjg7e2Nt7e3NsgQFRWlPTc9PV27xGHIkCF6bdWoUUMnYPKgvXv3AjBs2DCD5V5eXpibmxMREUFubuGWyiYmJnh4eJCXl6ddqpKfn88ff/xBkyZNtAGNB2eWaJbUlCQ4UqtWLapUqcLly5c5d+7cI8+PiIjg1q1bNG/enGbNmhk8p3fv3npjepIcHBzo2rVrsedcvXqVzz//HH9/f51nrFkWVJJrf5CJiYnBJMAtWrQAIC4uzqj2AIYOHap3zNHREQcHB/Ly8rh27Zr2uCaY4+XlRe3atfXq+fj4YGJiYvQYhBBCCCGE+DeSZTXPuGrVCoDSbw+Vlwf37pU+RmZpmU9p368Kx152OnXqRKdOnbh37x6RkZGcOnWK//3vf4SHh5OQkMCIESP4+eefcXV1NardL774gkWLFhW7DVdycrL2n69cuUJBQQE1a9bUbuP1sCZNmugdy8jIID4+HoCAgIBix3T//n3u3r2rnQ3Qrl07fv31V44ePUr37t2JiooiJSUFHx8fGjRogKOjo04gQjOLpCTBERMTE0aPHs3KlSvp06cPHh4edOzYEU9PTzw9PfWWmly4cAGA+Ph4vL29DbapybeRmJj4yP7LglqtLrZ8w4YNzJ07t9iZFA8+45JwdHTE3Nxc77idnR2ANh+MMZycnAwet7OzIzExkczMTO2x2NhYwPBnDQpz9dSrV6/Y/DdCCCGEEEJUFhIcecY9bs6OzEwFbdrUJjXV+ACJtXU+J0/exNKybIMcj8vS0pJ27drRrl07xo0bx/Hjxxk+fDiZmZmsXr2axYsXl7ito0ePsnDhQkxMTJg1axa9e/emXr16WFpaolAo+Pjjj1m2bJl2FgegfUGtVq1ake0aKnswQWdJkpU+uIRCE+TQBD00/6vJR9K+fXu2bt1KQkICZmZmXL58GQcHh0cGDTTeffdd6tSpw7p16zh27Jh25kn16tUZNWoU06ZN0y4B0lzH33//zd9//13ia3iSilrGBHD+/Hlmz55Nfn4+U6ZM4eWXX6Zhw4ZYWVmhUCgIDg4mMDBQ5xk/Tp+aJTEFBcb/3hjTpuZzWLVq1SLbK65MCCGEEEKIykSCI5WclVUBPj6ZrFlT9It8UXx9MytcYMQQT09PRo0axcqVKw3u6FGcrVu3AjB+/HgmTZqkV379+nW9Y5oX2OJmBqSnp+sde/BF9cqVK5iZmZV4nC1btsTCwoLIyEgyMzM5evQoCoVCu5ONJjhy9OhRTE1NtcdKSqlU4ufnh5+fH/Hx8Rw9epRff/2VvXv3snz5ctLT05k/f77OdQwaNIgvvviixH2Ulx07dpCfn8+wYcN455139MoNPeNngeZz+OBskoeVZvaKEEIIIYQQ/0aSc0QwalQmSqVxQQ6lsoCRI4t+6apoNDuyPLxsQvGIrXY0ORzatGljsPzBXCMaTk5OKJVKkpKSuHnT8MwezdKTB1lbW2uX4URHRxc7roeZmZnRpk0bcnNz+eOPPzh+/Dju7u7Y2toCujNLNLM+NIETY9WvXx9fX19WrFjB2rVrAQgJCdEuO2rUqBFg+BorIs0zbtu2rcFyQ8/4WeDi4gIUzowxJD09XSdHiRBCCCGEEJWZBEcErq65zJ2b+ugTHzB3biqursYtM3hSkpKSHrlE4Y8//gDA2dlZ57gmX0ZRyzs05Xfu3NErO3jwoMEX52rVqtGqVSsAwsLC9MpTU1P5+eefDfbXt29fAL7++muD5cXRBEDWrVtHUlKSzswQtVqNg4MD4eHh2twjmiU3j6N169ZA4f3T5OTw9PTE1taWqKiox0qC+7RonvHt27f1yiIjIzl8+PDTHlKZ6NKlC1C4K46ha9uyZQt5eXlPe1hCCCGEEEJUSBIcEQD4+2cQGJjyyBkkSmUB8+al4O9fcabj//DDD/Tq1YuNGzeSlJSkU5aSksLixYu1y2Me3j1Gs0VvUbumeHp6AvDll1/q7C7y559/Mm3aNL1kpBpjxowBYOnSpezbt097PDk5mQkTJhS5nGHChAnUqFGDzZs3ExgYSEpKik753bt3CQkJYenSpXp1NcEQTX8PL5tp164dV65cITo6GltbW+0Mj0e5ePEiAQEB/PnnnzpBqKysLJYtWwZAvXr1tLNULCwsePvttwEYO3Yse/fu1QteXbhwgfnz55cot8qT5uHhARQGpC5evKg9Hh0dzYQJE4p8xhVd8+bN6dChA/fu3WPcuHE6Ab7Dhw/z0UcfGbV0SwghhBBCiH8zyTkitPz9M/DyymLDBis2b7bSSdJqbZ2Pr28BOMTnAAAgAElEQVQmI0dmVpgZIxoKhYLz588TEBBAQEAADRo0oFatWiQnJ5OQkEB2djYA48aN087M0PD29mbNmjV8+eWX7N27FwcHBxQKBRMnTsTLy4vhw4ezYcMGrly5QteuXVGr1WRnZ3Pp0iUaNWrEgAED+Oqrr/TG1L9/f1599VVCQkJ44403aNiwITVq1CA6OhoLCwvGjx/PsmXL9LZSdXR0ZN26dYwePZrg4GDWrVuHq6srFhYWJCUlERcXR0FBAQMGDNDrs3Xr1pibm2uv9+HgSPv27fnxxx+1//yoJUUa2dnZbNy4kY0bN2JjY0ODBg0oKCggLi6O1NRUzM3N+eijj3TqjBo1iuvXr7N8+XL8/PyoUaMGTk5O5OXlER8fr51l0rFjxxKN4Uny9vbm66+/Jioqil69emmT1F68eBGVSsX48eP57LPPynmUpbNkyRLtltOenp64u7uTlpZGbGws3t7eXL58mcjISNnSVwghhBBCVHoyc0TocHXNJSgolYiIm+zefZvQ0Dvs3n2biIibBAVVnKU0Dxo1ahRhYWGMHz+etm3bkpeXx7lz50hMTESlUuHj48O2bdt477339Oq2b9+eVatW0apVKxITEzl69Cjh4eHcunULKNyNZdu2bfj4+FCtWjUuXbpETk4OY8aMYefOncXuSLN48WIWLFhAkyZNSExM5Nq1a/Tq1Ytdu3ZRu3ZtwPBuIR4eHhw4cIApU6bg5uZGXFwc58+fR6FQ4OXlxYIFCwgKCtKrZ2FhQcuWLQFwdXXVbvOr8eAyGmPyjbi4uLB48WL69++Pra0tly9fJjY2ljp16jBixAh+/fVXunfvrldv1qxZbN++nVdeeQUrKyuioqKIj4+nbt26vPrqq2zYsIHOnTuXeBxPSpUqVQgLC2PEiBHa60tPT2fEiBHs2bOHWrVqlfcQS61hw4bs2bOHwYMHU716daKjozExMWH27NksW7asRDvaCCGEEEIIURkoCkqzn6QoE7dv39ZLEGpIamoq1tbWT2FElY9mWUFJnkNZmjNnDmvXriUwMBB/f/+n2rcQULgsqkmTJuTm5nLx4kWd5UPl9XvxrJHv5spFqVRqk2YnJiZqk1CLp0+ehRCiIpPvqIrHzMxM7w/HhsjMESGesoyMDHbv3g38k+9CiKdt+/btZGVl8fzzzz+zeVWEEEIIIYQoKxIcEeIJCQ4O5uzZszrHbty4gb+/P7du3aJ58+baZTBCPAnx8fEEBwfrJfb9+eefCQwMBGDEiBHlMDIhhBBCCCEqFknIKsQTonkBtba2pkGDBmRnZxMTE0N+fj62trYGd5wRoixlZGQQGBhIUFAQjo6O2NnZkZCQoN3at3///gwePLicRymEEEIIIUT5k+CIEE/If/7zH2xsbDhz5gwxMTFAYYLM7t27M378eOrWrVvOIxT/diqVijfffJODBw8SHx/PuXPnsLKyon379gwePBhfX98S71okhBBCCCHEv5kkZC1HkpC1/EniSSH0ye9Fych3c+UiCfYqDnkWQoiKTL6jKh5JyCqEEEIIIYQQQghRAhIcEUIIIYQQQvy/9u48quo6/+P483IBEQHZUcAlxQ01BZc0nVCmND1pCmVu1cx02rSx0z5WOk6Oo5GJdUZrjtXMFE5JiobLlLk1KSruCiVuaELIYrKILJfL/f3hjzsS4BgiF7ivxzmdw/18P5/vfX/v7fP5wtvP5/MVEbFrSo6IiIiIiIiIiF1TcqQZsFgsaGsYEZGmQ+OyiIiISMui5EgzYDQatZGPiEgTUlFRgaOjHvgmIiIi0lIoOdIMODs7U1paauswRESEq7NGSkpKaNWqla1DEREREZEGouRIM+Dk5ERlZSUlJSWaxi0iYiMWiwWTyURRURHOzs6aOSIiIiLSgug3u2bAYDDg5uZGWVkZRUVFtg6nRXF2dgagvLzcxpGINB3qF7WzWCw4Ojri6uqqxIiIiIhIC6Pf7poJg8GAi4sLLi4utg6lxXBwcKBdu3YAXLhwQfu6iKB+ISIiIiL2SctqRERERERERMSuKTkiIiIiIiIiInatWS+rWbZsGd98881168TFxVnXz18rIyODhIQEUlJSKC4uxtvbm0GDBhEdHU2bNm1uVcgiIiIiIiIi0sQ06+RIlfbt2+Ph4VHrMQeHmpNjUlJSWLRoEeXl5Xh4eBAcHMyPP/7Ihg0b2LdvH/Pnz8fT0/NWhy0iIiIiIiIiTUCLSI5MnDiRESNG3FDdkpISli5dSnl5OWPGjOHhhx/G0dGRoqIiYmJiSEtL4/333+cPf/jDrQ1aRERERERERJoEu9tz5Ouvv6awsJCgoCAeffRR6+MY3d3defbZZzEajRw8eJAzZ87YOFIRERERERERaQx2lxzZu3cvACNGjKix5MbX15e+ffsCsGfPnkaPTUREREREREQaX4tYVrNnzx6Sk5MpKSmhbdu29OjRg4iICFxdXavVM5vN1hkhPXr0qPVcPXr04PDhw5w6darB4rt48WK110ajEU9PTwwGQ617okjjuPaz1/cgcpX6hUjt1DeaDn0XItKUaYxqegwGww3VaxHJkYMHD1Z7nZSURHx8PM8++yz9+/e3lufm5mI2mwEICAio9VxV5VlZWQ0W39NPP13tdffu3fnzn/+Mr69vg72H3Bx/f39bhyDS5KhfiNROfaPp0HchIk2ZxqjmpVknRwICApgyZQrh4eH4+/tjMBg4ceIEq1at4uTJk7z11lu88cYbdO3aFYDLly9b29b1uN6q8uLi4lsWt5+f3y07t4iIiIiIiIj8Ms06OfLAAw/UKLv99tsJDQ1l7ty5nDp1ipUrVzJ37lwATCaTtV7VRqw/5+TkBEB5eXmDxfnee+812Lmk4eTn57Nw4UIAZs+ercc3i6B+IVIX9Y2mQ9+FiDRlGqOar2adHKmLo6MjDz30EAsWLCA1NZXLly/j5uZmTXwAVFRU4OzsXKNtVQKltmP15ePj02DnkoZjNptJT0+3/iwi6hcidVHfaDr0XYhIU6YxqvlqsTvEdO/eHQCLxUJOTg4Abm5u1uN1LZupKq9r2Y2IiIiIiIiItCwtNjliNBqtP1dl7Pz8/Kzl2dnZtbarKm/fvv0tjlBEREREREREmoIWuawGICMjw/pz1bIWo9FIly5dOHnyJGlpafTs2bNGu7S0NABCQkIaJ1CxGR8fH+Lj420dhkiTon4hUjv1jaZD34WINGUao5qvFjtzZP369QAEBQXh7e1tLR88eDAAO3bsoLKyslqbvLw8jh07BsCQIUMaKVIRERERERERsaVmmxw5evQo//rXv6z7iVS5cuUKH330Ebt27QIgOjq62vF77rkHd3d3MjMz+ec//0lFRQUARUVFvPPOO5jNZsLCwujSpUvjXIiIiIiIiIiI2JTBYrFYbB1EfSQnJ7N48WIAvL298fLywmw2k5GRQUVFBQaDgejoaCZNmlSj7bFjx1i0aBEmkwkPDw98fX3JzMykrKwMPz8/FixYoEcuiYiIiIiIiNiJZpscycvLY8uWLZw4cYILFy5QWFiIxWLBy8uLnj17Mnr0aLp161Zn+/Pnz7NmzRpSU1MpLi7G29ubwYMHExUVVe2pNiIiIiIiIiLSsjXb5IiIiIiIiIiISENotnuOiIiIiIiIiIg0BCVHRERERERERMSuKTkiIiIiIiIiInZNyRERERERERERsWtKjoiIiIiIiIiIXVNyRERERERERETsmpIjIiIiIiIiImLXlBwREREREREREbum5IiIiIiIiIiI2DUlR0RERERERETErik5IiIiIiIiIiJ2zdHWAYg0tJycHI4ePcqpU6c4ffo058+fp7Kykoceeojo6Ojrtj1x4gTr1q0jLS2N0tJS/P39GTZsGOPHj8fZ2bmRrkDk1riZvnGtrVu38re//Q2AyMhInnrqqVsVssgtV99+UVJSwsaNG0lOTiYrK4uKigo8PT3p1asX9913H126dGnEq2j+LBYLaWlp7Nu3j+PHj5OZmUlZWRkeHh5069aNe++9lz59+tTZXvdvEbnVbnacAkhKSmL79u2cPXuW4uJi3N3d6dixI0OHDiUyMrKRrkTqouSItDibNm1i06ZNv7jdt99+y7Jly6isrMTb2xtfX19++OEH4uPjOXDgAPPmzaNVq1a3IGKRxlHfvnGtwsJCVq5c2UARidheffpFQUEBc+fOJSsrC4PBgL+/Py4uLmRnZ7Nz506SkpJ45plnGD58+C2KuuVJSUlh/vz5ABgMBtq1a4eLiwtZWVkkJyeTnJxMVFQUkydPrtFW928RaQw3M06ZTCZiY2PZv38/AAEBAfj6+pKfn8/Ro0cpKipScqQJUHJEWhx3d3fCw8MJCQkhJCSErVu3snfv3uu2ycnJ4f3336eyspLp06czbtw4DAYDubm5LFiwgNOnTxMXF8djjz3WSFch0vDq0zd+7h//+AfFxcWEh4dz8ODBWxSpSOOpT7/49NNPycrKIjAwkJdeeomgoCAASktL+fjjj9myZQsrVqwgPDwcV1fXxriMZs9isdCuXTvuu+8+7rzzTtzc3ACoqKggPj6edevWkZCQQLdu3RgwYIC1ne7fItJY6jtOASxfvpz9+/fTq1cvnnzySQIDA63HCgsLSU9Pb9RrkdopOSItzs+nQe/atet/tklMTMRkMtGvXz/Gjx9vLffz8+Ppp59mzpw5bNmyhejoaDw9PRs8ZpHGUJ++ca2jR4+yc+dORo0ahYeHh5Ij0iLUp19U/b8/ffp0a2IEwMXFhccee4y9e/dSVFREWloaYWFhDRtwCxUSEkJsbCxGo7FauaOjI1OnTuXcuXMcOnSIrVu3VvujQ/dvEWks9R2nDh8+zK5duwgKCuK1116rsdTPw8ODfv36Nco1yPVpQ1axexaLhX379gEwcuTIGsd79OhBUFAQZrPZOhVOxN6Ul5fzwQcf0LZtW6ZMmWLrcERsqry8HLg6LfrnjEYjfn5+AJjN5kaNqzlzdXWt8QfHtfr27QtAVlaWtUz3bxFpTPUZpwA2btwIQFRUlPZAauKUHBG7l5eXx6VLlwDo2bNnrXV69OgBwMmTJxstLpGmJCEhgQsXLjB9+nTatGlj63BEbKpTp04ApKWl1Th2+fJlMjMzMRqNdO7cuZEja7lMJhNAtT8sdP8WkaaktnGqvLyclJQUDAYD4eHhpKam8t577/HGG2+wePFiNm7cSElJia1Clp/Rshqxe1XZXScnJ7y8vGqt4+/vD8CFCxcaLS6RpiIjI4PExER69epFRESErcMRsbkHH3yQBQsWEBcXh9FoJCwsDBcXF86ePUtcXBxlZWVERUXh6+tr61BbBIvFwp49e4D/JjtA928RaTrqGqfOnj2L2WzG29ubL774gnXr1lVrl5ycTGJiIrNnz1ZCvQlQckTsXnFxMXB1qpzBYKi1TtWGS5cvX260uESaAovFwooVK7BYLNrQUOT/9enThzlz5rBq1Sree++9asf8/Pz4/e9/z69+9SsbRdfybN26lfT0dBwdHRk7dqy1XPdvEWkq6hqn8vPzgatPOVu3bh0DBgzg4Ycfxt/fn7Nnz7JixQrS09OJiYlhyZIluLi42OoSBC2rEbFOgXN0rDtXWHWsap25iL3Ytm0b33//PWPHjqVjx462DkekycjJyaGgoACDwYCfnx8dO3bE2dmZ3Nxctm3bRk5Ojq1DbBHOnDnD3//+dwAmT55Mu3btrMd0/xaRpuB641RpaSlwdQ+qgIAAXnjhBQIDA3F0dCQkJITZs2fTqlUr8vLy2L59u03il/9SckTsnpOTE3D1MVx1qTqmTZTEnhQWFrJy5Up8fHx48MEHbR2OSJOxdu1ali9fjsFgICYmhmXLlrF48WI++OADIiMjSU1NZc6cOVy5csXWoTZrOTk5vPnmm5hMJoYPH864ceOqHdf9W0Rs7X+NU9eOPaNGjaqRzPX09OTOO+8Erj7VRmxLyRGxe1WbS165cgWLxVJrnarpuFXTc0XsQVxcHJcvX+bRRx/VNE+R/1dQUMDq1asBmDFjhnVzVrj6KN/HH3+c4OBgLl26xFdffWWrMJu9/Px85s+fz6VLlwgPD2fGjBk1ls7o/i0itvRLximg2qPfr1VVnpube+uClRuiPUfE7rVv3x64Oj330qVLeHt716hTNT362mlyIi1deno6AB9++CEffvhhtWNV00R37tzJgQMHAFixYkXjBihiA6dPn8ZkMuHi4kJISEiN40ajkdDQUDIyMjh9+rQNImz+Ll++zPz588nOziY0NJTnn3++1qUzun+LiK3c6DgVGBho/bmuJYBVs+AqKytvTbBywzRzROyer68vnp6eABw/frzWOlWPa+zWrVujxSXSVBQUFNT4r6ysDLi6jr+qTMQeVCUGb0TVnhhy40pLS1m4cCHnz5+na9euvPLKK3UuidH9W0Rs4ZeMUz4+Pvj4+ADUuRdVdnY2QK0JXmlcmjkids9gMDB48GA2b97M9u3brev+qqSlpZGZmYnRaGTgwIE2ilKk8b311lt1HouPj2f16tVERkby1FNPNWJUIrZVNQOhtLSUU6dO1fij22w289133wH/ndkgN8ZkMhETE8PJkyfp0KEDr732Gq1bt66zvu7fItLYfuk4BTB06FA2bNjAN998w913313tWHl5Obt37wauPglNbEszR0SA8ePH4+joyJEjR0hMTLSuXc7NzbU+pvHXv/619V+oRETEPt12220EBwcDsHz5cs6dO2c9VlJSwooVK8jIyADgrrvuskmMzVFlZSVLly4lJSWFgIAAXn/99RvaJ0T3bxFpLDczTrm4uJCWlkZCQoJ1+Ux5eTkrVqzg0qVLtGnTpkbiRBqfwVLXDlYizdTx48er/Yt3aWkpJpOJVq1aVZvy9uabb+Lr62t9/c0337B8+XIsFgve3t60bduWH374AbPZTJcuXZg3b542pZRmrb59ozaaOSItRX36xZkzZ5g/fz7FxcUYDAZ8fX1xdXUlKyvL+sjYyZMnExUV1bgX04zt3LmTd999F7g648bDw6PWel5eXjz//PPVynT/FpHGcDPj1P79+1myZAkVFRW0bdsWX19fsrKyuHLlCq1ateLFF1+kX79+t/wa5Pq0rEZaHLPZTFFRUY3ysrIy6z4JUHPTo4iICNq1a8fatWs5ceIEGRkZBAQEMGzYMO6//349BlCavfr2DZGWrD79okuXLrz99tts2LCBw4cPk5OTw08//YSHhwdhYWGMHj1a06N/oWsfx5uVlUVWVlat9fz8/GqU6f4tIo3hZsapgQMHsmjRIhISEvjuu+84e/YsHh4eDBw4kIkTJ9b5JBtpXJo5IiIiIiIiIiJ2TXuOiIiIiIiIiIhdU3JEREREREREROyakiMiIiIiIiIiYteUHBERERERERERu6bkiIiIiIiIiIjYNSVHRERERERERMSuKTkiIiIiIiIiInZNyRERERERERERsWtKjoiIiIiIiIiIXVNyRERERERERETsmpIjIiIiUsOOHTuYNGkSp0+ftnUojWbmzJksW7aswc5X9RlW/Td58mSeeOIJli5dSlZWVoO9T23mzZvHpEmTWLBgQY1jOTk5TJo0icTExF983rKyMuLj40lNTW2IMEVERJoMR1sHICIiItIUvPjii7Ru3brBzztjxgwCAwMxmUykpaWRkJBAamoqsbGxuLm5Nfj7XevIkSOkpKTQp0+fBjlfWVkZq1evBqB3794Nck4REZGmQDNHREREpEUoLy+/qfa33XYb7dq1a6Bo/qtDhw50796d3r17ExUVxYQJEygoKGDfvn0N/l7Xat++PQEBAcTFxWGxWG7pe4mIiDR3mjkiIiIi9VJeXs5nn33GsWPHyMnJwcHBgcDAQCZMmMCgQYOs9d544w1++uknYmNjMRgM1nKLxcKsWbMIDAxk9uzZAFRUVPDFF1/w7bffkpOTQ+vWrRkwYADTp0/Hw8PD2nbmzJl06NCBkSNHsmbNGjIzMxk7dizTpk1j9+7drF+/nszMTMxmM56enoSGhjJjxozrXs/MmTMJDQ1l5syZAKSmpvKnP/2JWbNmcf78eXbs2EFpaSkhISE89thjBAYG1utz69KlCwAFBQU1jiUlJbFx40Z++OEHAHr27MnUqVO57bbbrHWys7P59NNP+f777ykqKqJNmzZ06NCBRx55hM6dO1vrOTo6EhUVxTvvvENSUhLDhg27blz5+fnEx8dz8OBBCgoK8Pb2ZsSIEURFRWE0GsnJyeGZZ54BYPXq1dYZJBEREdbPTEREpLlSckRERETqpaKigsuXLzNu3Di8vb2pqKjg2LFjLF68mBkzZhAREQHA2LFjiYmJ4dixY9x+++3W9ocOHSI7O5vf/va3AFRWVhITE8P333/P/fffT/fu3cnLyyM+Pp558+axaNEinJ2dre3T09PJzMwkKioKf39/WrVqxYkTJ1i6dClDhw7lwQcfxMnJiby8PFJSUup9nZ9++ik9evTgySefpKSkhJUrV/Lmm28SGxuLg8Mvn4Sbk5MDXJ3Zca2EhARWrVrFiBEjiI6OpqKigsTERObOncvChQsJDg4GYOHChVRWVjJt2jR8fX0pKioiLS2N4uLiGu915513sn79ej777DPuuOMOHB1r/9UvPz+f2bNn4+DgwAMPPEBAQAAnTpwgISGB3NxcZsyYgZeXF6+++ip/+ctfiIyMJDIyEqBa0kpERKS5UnJERERE6sXV1bXabIzKykr69u1LcXExmzZtsiZHwsPDCQgI4Msvv6yWHPnqq68ICAggLCwMgN27d3P48GFeeOEF7rjjDmu9Tp06MXv2bHbs2MGoUaOs5QUFBSxZsqTaDI7169djsVh44okncHV1tZaPGDGi3tcZHBzMrFmzrK8dHByIjY3l1KlTdO/e/X+2r6ysxGw2YzKZOH78OAkJCfTq1YuBAwda6+Tl5fH5558zevRofve731nLb7/9dmbNmsXnn3/Oc889R1FRET/++CO/+c1vuOuuu6z1rv28rmUwGJg2bRrz589ny5Yt3HvvvbXWi4+Pp7i4mCVLluDr6wtA3759cXZ25pNPPmH8+PEEBwdbZ714e3vf0LWLiIg0F0qOiIiISL3t3r2bTZs2cfbsWcrKyqzlTk5O1p8dHBwYPXo0cXFx5OXl4evry4ULFzh8+DAPP/ywdanNgQMHaNOmDQMGDMBsNlvbd+7cGU9PT1JTU6slRzp16lRjaUvXrl0BiI2NZeTIkfTs2RNvb++busZrkxhV7wtXExo3kiB47bXXqr0OCgri5Zdfxmg0WsuOHDmC2WwmIiKi2rU7OTkRGhpqfTqMm5sbAQEBJCYmUllZSe/evenUqdN1Z7D07duXfv36sXr1amvC6ucOHjxI79698fLyqvb+YWFhfPLJJ3z33XfWmSsiIiItkZIjIiIiUi979+4lNjaWIUOGMG7cODw9PTEajWzevJnt27dXqxsZGUl8fDybN29m6tSpfPXVVzg7OzNy5EhrnYKCAoqLi5k6dWqt71dUVFTttaenZ406oaGhvPTSS/z73/9m2bJlmEwmOnTowMSJExk+fHi9rtPd3b3a66qlKTe6AewzzzxDUFAQJSUlJCUlsWXLFt555x1effVVa52q/Ueq9l75uaoEksFgYO7cuaxevZovvviCjz/+GDc3N4YPH86UKVPqfNrOtGnTeOWVV1i/fn2ts2gKCgo4cOAAU6ZMqbV9YWHhDV2riIhIc6XkiIiIiNTLt99+i7+/P88991y1jVZNJlONuq6urkRERLBt2zbGjx/Pjh07GDZsGG3atLHWcXd3x93dvVrS4Fo//8P/2ve81qBBgxg0aBAmk4mTJ0+ydu1a3n33Xfz9/W2yFCQoKMg6o6VPnz5UVlaybds29uzZw5AhQ4D/JmCef/55/Pz8rns+Pz8/nn76aQB+/PFHdu/ezeeff05FRQVPPPFErW06d+7MsGHD2LBhg3UZ07Xc3d3p1KkTkydPrrW9l5fXjV2siIhIM6XkiIiIiNSbo6NjtSRFfn4++/fvr7XumDFj2Lx5M2+//TbFxcU19r8YMGAASUlJVFZW0q1bt5uOrWpJiqurK0eOHCE9Pb1J7JMxffp09u7dy6pVqxg8eDAODg7069cPo9FIdna2NWFyIwIDA4mOjmbv3r2kp6dft+7kyZPZs2eP9Skz1woPD+fQoUMEBATg5uZW5zmqlkvd7GOTRUREmholR0RERKROKSkp5Obm1igPCwtjwIABJCcn88EHHzBkyBDy8vJYs2YNXl5eZGVl1WgTGBhI//79OXToED179qz22FmAYcOGsXPnThYuXMjYsWMJCQnBaDRy8eJFUlNTGTRoEIMHD75uvKtWreLixYv07dsXHx8f6+awRqOR0NDQm/osGoqbmxsTJ04kLi6OnTt3ctddd+Hv78+kSZP47LPPyM7Opn///ri5uZGfn8+pU6dwcXFh0qRJnDt3jo8++oghQ4bQvn17HB0dSUlJ4dy5c0yYMOG67+vv78+oUaPYtGlTjWMPPfQQx44dY86cOYwZM4bAwEDKy8vJzc3l0KFDPP744/j4+NC6dWv8/PzYv38/ffv2xc3NDXd3d/z9/W/VxyUiItIolBwRERGROq1cubLW8r/+9a+MHDmSgoICvv76a7Zv346/vz8TJkzg4sWLtc5OABg6dCiHDh2q9akpDg4OvPzyy2zatIn//Oc/rF27FqPRiI+PD7169aJjx47/M95u3bpx5swZVq5cSWFhIW3atKFLly788Y9/pEOHDr/s4m+he++9ly+//JI1a9YwfPhwHBwcmDhxIsHBwWzatIldu3ZRUVGBp6cnXbt25Z577gGu7rMSEBDA5s2bycvLw2AwEBAQwCOPPMKYMWP+5/tGRUWxfft2SkpKqpV7eXmxcOFC1qxZQ2JiIhcvXqR169b4+/vTv5J3NIQAAADvSURBVH//asufnnrqKeLi4oiJicFkMhEREcHMmTMb9gMSERFpZAaLxWKxdRAiIiJiHxYvXszJkydZtmyZdWNTEREREVvTbyUiIiJyS5lMJtLT0zl16hT79u3jkUceUWJEREREmhT9ZiIiIiK31KVLl3j99ddp3bo1d9999w0t/xARERFpTFpWIyIiIiIiIiJ2zcHWAYiIiIiIiIiI2JKSIyIiIiIiIiJi15QcERERERERERG7puSIiIiIiIiIiNg1JUdERERERERExK4pOSIiIiIiIiIidk3JERERERERERGxa0qOiIiIiIiIiIhd+z/hItCkFNnL2QAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1280x880 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1280x880 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for dataset in ['imagenette', 'imagewoof', 'cifar10'] :\n",
    "    imagenette_acc_stagewise = list()\n",
    "    imagenette_acc_simultaneous = list()\n",
    "    imagenette_acc_noteacher = list()\n",
    "    for model in ['resnet10', 'resnet14', 'resnet18', 'resnet20', 'resnet26'] :\n",
    "        noteacher_acc, stagewise_acc = check(model, dataset)\n",
    "        simul_acc = check_simultaneous(model, dataset)\n",
    "        imagenette_acc_noteacher.append(noteacher_acc * 100)\n",
    "        imagenette_acc_stagewise.append(stagewise_acc * 100)\n",
    "        imagenette_acc_simultaneous.append(simul_acc * 100)\n",
    "\n",
    "    teacher_acc = check_teacher('resnet34', dataset) * 100\n",
    "\n",
    "    layers = [10, 14, 18, 20, 26]\n",
    "\n",
    "    with plt.style.context('ggplot'):\n",
    "        fig, ax = plt.subplots()\n",
    "        title_ = dataset[0].upper() + dataset[1 : ] + ' Accuracy'\n",
    "        ax.set(xlim = [8, 28], ylim = [50, 100], xlabel = 'Layers in ResNet', ylabel = 'Validation Accuracy', title = title_)\n",
    "        ax.axhline(teacher_acc, ls = '--', color = 'r', label = 'Teacher Model')\n",
    "        ax.plot(layers, imagenette_acc_noteacher, 'go-', label = 'Training without Teacher')\n",
    "        ax.plot(layers, imagenette_acc_simultaneous, 'co-', label = 'Simultaneous Training')\n",
    "        ax.plot(layers, imagenette_acc_stagewise, 'bo-', label = 'Stagewise Training')\n",
    "        plt.xticks(layers)\n",
    "        ax.legend(loc = 'best')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for dataset in ['imagenette', 'imagewoof', 'cifar10'] :\n",
    "    imagenette_acc_stagewise = list()\n",
    "    imagenette_acc_stagewise8 = list()\n",
    "    imagenette_acc_noteacher = list()\n",
    "    imagenette_acc_noteacher8 = list()\n",
    "    for model in ['resnet10', 'resnet14', 'resnet18', 'resnet20', 'resnet26'] :\n",
    "        noteacher_acc, stagewise_acc = check_ld(model, dataset)\n",
    "        noteacher_acc8, stagewise_acc8 = check_ld8(model, dataset)\n",
    "        imagenette_acc_noteacher.append(noteacher_acc * 100)\n",
    "        imagenette_acc_noteacher8.append(noteacher_acc8 * 100)\n",
    "        imagenette_acc_stagewise.append(stagewise_acc * 100)\n",
    "        imagenette_acc_stagewise8.append(stagewise_acc8 * 100)\n",
    "\n",
    "    teacher_acc = check_teacher('resnet34', dataset) * 100\n",
    "\n",
    "    layers = [10, 14, 18, 20, 26]\n",
    "\n",
    "    with plt.style.context('ggplot') :\n",
    "        fig, ax = plt.subplots(figsize = (10, 10))\n",
    "        title_ = 'Less Data ' + dataset[0].upper() + dataset[1 : ] + ' Accuracy'\n",
    "        ax.set(xlim = [8, 28], ylim = [30, 100], xlabel = 'Layers in ResNet', ylabel = 'Validation Accuracy', title = title_)\n",
    "        ax.axhline(teacher_acc, ls = '--', color = 'r', label = 'Teacher Model')\n",
    "        ax.plot(layers, imagenette_acc_noteacher, 'go-', label = 'Training without Teacher using 1/4th data')\n",
    "        ax.plot(layers, imagenette_acc_noteacher8, 'co-', label = 'Training without Teacher using 1/8th data')\n",
    "        ax.plot(layers, imagenette_acc_stagewise, 'bo-', label = 'Stagewise Training using 1/4th data')\n",
    "        ax.plot(layers, imagenette_acc_stagewise8, 'mo-', label = 'Stagewise Training using 1/8th data')\n",
    "        plt.xticks(layers)\n",
    "        ax.legend(loc = 'best')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_ldp(model_name, dataset, perc) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    new_path = path/('new' + str(perc))\n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(new_path, train = 'train', valid = 'val', test = 'test', bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/less_data' + str(perc) + '/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    savename = '../saved_models/' + dataset + '/less_data' + str(perc) + '/' + model_name + '_no_teacher/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('no_teacher : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_noteacher_acc = _get_accuracy(data.valid_dl, net)\n",
    "    \n",
    "    return ld_noteacher_acc, ld_stagewise_acc\n",
    "#     return ld_noteacher_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "(0.804, 0.866)\n",
      "(0.79, 0.878)\n",
      "(0.764, 0.826)\n",
      "(0.77, 0.836)\n",
      "(0.748, 0.854)\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_ldp('resnet10', 'imagenette', 10))\n",
    "print(check_ldp('resnet14', 'imagenette', 10))\n",
    "print(check_ldp('resnet18', 'imagenette', 10))\n",
    "print(check_ldp('resnet20', 'imagenette', 10))\n",
    "print(check_ldp('resnet26', 'imagenette', 10))\n",
    "\n",
    "# print('20 percent :')\n",
    "# print(check_ldp('resnet10', 'imagenette', 20))\n",
    "# print(check_ldp('resnet14', 'imagenette', 20))\n",
    "# print(check_ldp('resnet18', 'imagenette', 20))\n",
    "# print(check_ldp('resnet20', 'imagenette', 20))\n",
    "# print(check_ldp('resnet26', 'imagenette', 20))\n",
    "\n",
    "# print('30 percent :')\n",
    "# print(check_ldp('resnet10', 'imagenette', 30))\n",
    "# print(check_ldp('resnet14', 'imagenette', 30))\n",
    "# print(check_ldp('resnet18', 'imagenette', 30))\n",
    "# print(check_ldp('resnet20', 'imagenette', 30))\n",
    "# print(check_ldp('resnet26', 'imagenette', 30))\n",
    "\n",
    "# print('40 percent :')\n",
    "# print(check_ldp('resnet10', 'imagenette', 40))\n",
    "# print(check_ldp('resnet14', 'imagenette', 40))\n",
    "# print(check_ldp('resnet18', 'imagenette', 40))\n",
    "# print(check_ldp('resnet20', 'imagenette', 40))\n",
    "# print(check_ldp('resnet26', 'imagenette', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "(0.482, 0.704)\n",
      "(0.452, 0.686)\n",
      "(0.438, 0.644)\n",
      "(0.46, 0.638)\n",
      "(0.428, 0.638)\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_ldp('resnet10', 'imagewoof', 10))\n",
    "print(check_ldp('resnet14', 'imagewoof', 10))\n",
    "print(check_ldp('resnet18', 'imagewoof', 10))\n",
    "print(check_ldp('resnet20', 'imagewoof', 10))\n",
    "print(check_ldp('resnet26', 'imagewoof', 10))\n",
    "\n",
    "# print('20 percent :')\n",
    "# print(check_ldp('resnet10', 'imagewoof', 20))\n",
    "# print(check_ldp('resnet14', 'imagewoof', 20))\n",
    "# print(check_ldp('resnet18', 'imagewoof', 20))\n",
    "# print(check_ldp('resnet20', 'imagewoof', 20))\n",
    "# print(check_ldp('resnet26', 'imagewoof', 20))\n",
    "\n",
    "# print('30 percent :')\n",
    "# print(check_ldp('resnet10', 'imagewoof', 30))\n",
    "# print(check_ldp('resnet14', 'imagewoof', 30))\n",
    "# print(check_ldp('resnet18', 'imagewoof', 30))\n",
    "# print(check_ldp('resnet20', 'imagewoof', 30))\n",
    "# print(check_ldp('resnet26', 'imagewoof', 30))\n",
    "\n",
    "# print('40 percent :')\n",
    "# print(check_ldp('resnet10', 'imagewoof', 40))\n",
    "# print(check_ldp('resnet14', 'imagewoof', 40))\n",
    "# print(check_ldp('resnet18', 'imagewoof', 40))\n",
    "# print(check_ldp('resnet20', 'imagewoof', 40))\n",
    "# print(check_ldp('resnet26', 'imagewoof', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "(0.5745, 0.7774)\n",
      "(0.5622, 0.7715)\n",
      "(0.5553, 0.7777)\n",
      "(0.5476, 0.7805)\n",
      "(0.5305, 0.7817)\n",
      "20 percent :\n",
      "(0.6329, 0.8153)\n",
      "(0.6226, 0.8132)\n",
      "(0.6155, 0.8212)\n",
      "(0.6199, 0.824)\n",
      "(0.6144, 0.8243)\n",
      "30 percent :\n",
      "(0.6732, 0.8248)\n",
      "(0.6664, 0.8274)\n",
      "(0.6637, 0.8348)\n",
      "(0.669, 0.8349)\n",
      "(0.6652, 0.8442)\n",
      "40 percent :\n",
      "(0.6948, 0.8295)\n",
      "(0.6905, 0.8358)\n",
      "(0.6942, 0.8416)\n",
      "(0.6954, 0.8482)\n",
      "(0.6964, 0.8519)\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_ldp('resnet10', 'cifar10', 10))\n",
    "print(check_ldp('resnet14', 'cifar10', 10))\n",
    "print(check_ldp('resnet18', 'cifar10', 10))\n",
    "print(check_ldp('resnet20', 'cifar10', 10))\n",
    "print(check_ldp('resnet26', 'cifar10', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_ldp('resnet10', 'cifar10', 20))\n",
    "print(check_ldp('resnet14', 'cifar10', 20))\n",
    "print(check_ldp('resnet18', 'cifar10', 20))\n",
    "print(check_ldp('resnet20', 'cifar10', 20))\n",
    "print(check_ldp('resnet26', 'cifar10', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_ldp('resnet10', 'cifar10', 30))\n",
    "print(check_ldp('resnet14', 'cifar10', 30))\n",
    "print(check_ldp('resnet18', 'cifar10', 30))\n",
    "print(check_ldp('resnet20', 'cifar10', 30))\n",
    "print(check_ldp('resnet26', 'cifar10', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_ldp('resnet10', 'cifar10', 40))\n",
    "print(check_ldp('resnet14', 'cifar10', 40))\n",
    "print(check_ldp('resnet18', 'cifar10', 40))\n",
    "print(check_ldp('resnet20', 'cifar10', 40))\n",
    "print(check_ldp('resnet26', 'cifar10', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_trad_ldp(model_name, dataset, perc) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    new_path = path/('new' + str(perc))\n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(new_path, train = 'train', valid = 'val', test = 'test', bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/trad_kd_ld' + str(perc) + '/' + model_name + '_classifier/model1.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "        \n",
    "    return ld_stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "0.774\n",
      "0.78\n",
      "0.77\n",
      "0.77\n",
      "0.742\n",
      "20 percent :\n",
      "0.866\n",
      "0.86\n",
      "0.864\n",
      "0.848\n",
      "0.856\n",
      "30 percent :\n",
      "0.9\n",
      "0.892\n",
      "0.894\n",
      "0.906\n",
      "0.906\n",
      "40 percent :\n",
      "0.916\n",
      "0.906\n",
      "0.922\n",
      "0.92\n",
      "0.92\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagenette', 10))\n",
    "print(check_trad_ldp('resnet14', 'imagenette', 10))\n",
    "print(check_trad_ldp('resnet18', 'imagenette', 10))\n",
    "print(check_trad_ldp('resnet20', 'imagenette', 10))\n",
    "print(check_trad_ldp('resnet26', 'imagenette', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagenette', 20))\n",
    "print(check_trad_ldp('resnet14', 'imagenette', 20))\n",
    "print(check_trad_ldp('resnet18', 'imagenette', 20))\n",
    "print(check_trad_ldp('resnet20', 'imagenette', 20))\n",
    "print(check_trad_ldp('resnet26', 'imagenette', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagenette', 30))\n",
    "print(check_trad_ldp('resnet14', 'imagenette', 30))\n",
    "print(check_trad_ldp('resnet18', 'imagenette', 30))\n",
    "print(check_trad_ldp('resnet20', 'imagenette', 30))\n",
    "print(check_trad_ldp('resnet26', 'imagenette', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagenette', 40))\n",
    "print(check_trad_ldp('resnet14', 'imagenette', 40))\n",
    "print(check_trad_ldp('resnet18', 'imagenette', 40))\n",
    "print(check_trad_ldp('resnet20', 'imagenette', 40))\n",
    "print(check_trad_ldp('resnet26', 'imagenette', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "0.51\n",
      "0.508\n",
      "0.498\n",
      "0.51\n",
      "0.462\n",
      "20 percent :\n",
      "0.706\n",
      "0.674\n",
      "0.716\n",
      "0.714\n",
      "0.728\n",
      "30 percent :\n",
      "0.77\n",
      "0.75\n",
      "0.774\n",
      "0.774\n",
      "0.796\n",
      "40 percent :\n",
      "0.796\n",
      "0.812\n",
      "0.788\n",
      "0.806\n",
      "0.808\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagewoof', 10))\n",
    "print(check_trad_ldp('resnet14', 'imagewoof', 10))\n",
    "print(check_trad_ldp('resnet18', 'imagewoof', 10))\n",
    "print(check_trad_ldp('resnet20', 'imagewoof', 10))\n",
    "print(check_trad_ldp('resnet26', 'imagewoof', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagewoof', 20))\n",
    "print(check_trad_ldp('resnet14', 'imagewoof', 20))\n",
    "print(check_trad_ldp('resnet18', 'imagewoof', 20))\n",
    "print(check_trad_ldp('resnet20', 'imagewoof', 20))\n",
    "print(check_trad_ldp('resnet26', 'imagewoof', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagewoof', 30))\n",
    "print(check_trad_ldp('resnet14', 'imagewoof', 30))\n",
    "print(check_trad_ldp('resnet18', 'imagewoof', 30))\n",
    "print(check_trad_ldp('resnet20', 'imagewoof', 30))\n",
    "print(check_trad_ldp('resnet26', 'imagewoof', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_trad_ldp('resnet10', 'imagewoof', 40))\n",
    "print(check_trad_ldp('resnet14', 'imagewoof', 40))\n",
    "print(check_trad_ldp('resnet18', 'imagewoof', 40))\n",
    "print(check_trad_ldp('resnet20', 'imagewoof', 40))\n",
    "print(check_trad_ldp('resnet26', 'imagewoof', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "0.6905\n",
      "0.681\n",
      "0.6844\n",
      "0.6808\n",
      "0.6742\n",
      "20 percent :\n",
      "0.7494\n",
      "0.7511\n",
      "0.7573\n",
      "0.7563\n",
      "0.7602\n",
      "30 percent :\n",
      "0.7789\n",
      "0.7754\n",
      "0.7845\n",
      "0.7826\n",
      "0.7866\n",
      "40 percent :\n",
      "0.7981\n",
      "0.8004\n",
      "0.8058\n",
      "0.8075\n",
      "0.8094\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_trad_ldp('resnet10', 'cifar10', 10))\n",
    "print(check_trad_ldp('resnet14', 'cifar10', 10))\n",
    "print(check_trad_ldp('resnet18', 'cifar10', 10))\n",
    "print(check_trad_ldp('resnet20', 'cifar10', 10))\n",
    "print(check_trad_ldp('resnet26', 'cifar10', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_trad_ldp('resnet10', 'cifar10', 20))\n",
    "print(check_trad_ldp('resnet14', 'cifar10', 20))\n",
    "print(check_trad_ldp('resnet18', 'cifar10', 20))\n",
    "print(check_trad_ldp('resnet20', 'cifar10', 20))\n",
    "print(check_trad_ldp('resnet26', 'cifar10', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_trad_ldp('resnet10', 'cifar10', 30))\n",
    "print(check_trad_ldp('resnet14', 'cifar10', 30))\n",
    "print(check_trad_ldp('resnet18', 'cifar10', 30))\n",
    "print(check_trad_ldp('resnet20', 'cifar10', 30))\n",
    "print(check_trad_ldp('resnet26', 'cifar10', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_trad_ldp('resnet10', 'cifar10', 40))\n",
    "print(check_trad_ldp('resnet14', 'cifar10', 40))\n",
    "print(check_trad_ldp('resnet18', 'cifar10', 40))\n",
    "print(check_trad_ldp('resnet20', 'cifar10', 40))\n",
    "print(check_trad_ldp('resnet26', 'cifar10', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_simult_ldp(model_name, dataset, perc) :\n",
    "    if dataset == 'imagenette' : \n",
    "        path = untar_data(URLs.IMAGENETTE)\n",
    "    elif dataset == 'cifar10' : \n",
    "        path = untar_data(URLs.CIFAR)\n",
    "    elif dataset == 'imagewoof' : \n",
    "        path = untar_data(URLs.IMAGEWOOF)\n",
    "    \n",
    "    new_path = path/('new' + str(perc))\n",
    "    val = 'val'\n",
    "    sz = 224\n",
    "    stats = imagenet_stats\n",
    "\n",
    "    tfms = get_transforms(do_flip=False)\n",
    "    load_name = dataset\n",
    "    if dataset == 'cifar10' : \n",
    "        val = 'test'\n",
    "        sz = 32\n",
    "        stats = cifar_stats\n",
    "        load_name = dataset[ : -2]\n",
    "\n",
    "    data = ImageDataBunch.from_folder(new_path, train = 'train', valid = 'val', test = 'test', bs = 64, size = sz, ds_tfms = tfms).normalize(stats)\n",
    "    \n",
    "    if model_name == 'resnet10' :\n",
    "        net = resnet10(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet14' : \n",
    "        net = resnet14(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet18' :\n",
    "        net = resnet18(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet20' :\n",
    "        net = resnet20(pretrained = False, progress = False)\n",
    "    elif model_name == 'resnet26' :\n",
    "        net = resnet26(pretrained = False, progress = False)\n",
    "    savename = '../saved_models/' + dataset + '/less_data' + str(perc) + '/simultaneous/' + model_name + '_classifier/model0.pt'\n",
    "    net.load_state_dict(torch.load(savename, map_location = 'cpu'))\n",
    "    net.cuda()\n",
    "#     print('stagewise : ', _get_accuracy(data.valid_dl, net))\n",
    "    ld_stagewise_acc = _get_accuracy(data.valid_dl, net)\n",
    "        \n",
    "    return ld_stagewise_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "0.5467\n",
      "0.5368\n",
      "0.5278\n",
      "0.5189\n",
      "0.5235\n",
      "20 percent :\n",
      "0.6179\n",
      "0.599\n",
      "0.5942\n",
      "0.5954\n",
      "0.5957\n",
      "30 percent :\n",
      "0.6518\n",
      "0.64\n",
      "0.6477\n",
      "0.6394\n",
      "0.6452\n",
      "40 percent :\n",
      "0.6757\n",
      "0.6744\n",
      "0.6765\n",
      "0.6737\n",
      "0.6816\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_simult_ldp('resnet10', 'cifar10', 10))\n",
    "print(check_simult_ldp('resnet14', 'cifar10', 10))\n",
    "print(check_simult_ldp('resnet18', 'cifar10', 10))\n",
    "print(check_simult_ldp('resnet20', 'cifar10', 10))\n",
    "print(check_simult_ldp('resnet26', 'cifar10', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_simult_ldp('resnet10', 'cifar10', 20))\n",
    "print(check_simult_ldp('resnet14', 'cifar10', 20))\n",
    "print(check_simult_ldp('resnet18', 'cifar10', 20))\n",
    "print(check_simult_ldp('resnet20', 'cifar10', 20))\n",
    "print(check_simult_ldp('resnet26', 'cifar10', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_simult_ldp('resnet10', 'cifar10', 30))\n",
    "print(check_simult_ldp('resnet14', 'cifar10', 30))\n",
    "print(check_simult_ldp('resnet18', 'cifar10', 30))\n",
    "print(check_simult_ldp('resnet20', 'cifar10', 30))\n",
    "print(check_simult_ldp('resnet26', 'cifar10', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_simult_ldp('resnet10', 'cifar10', 40))\n",
    "print(check_simult_ldp('resnet14', 'cifar10', 40))\n",
    "print(check_simult_ldp('resnet18', 'cifar10', 40))\n",
    "print(check_simult_ldp('resnet20', 'cifar10', 40))\n",
    "print(check_simult_ldp('resnet26', 'cifar10', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "0.752\n",
      "0.766\n",
      "0.772\n",
      "0.746\n",
      "0.76\n",
      "20 percent :\n",
      "0.826\n",
      "0.826\n",
      "0.806\n",
      "0.82\n",
      "0.814\n",
      "30 percent :\n",
      "0.858\n",
      "0.86\n",
      "0.866\n",
      "0.858\n",
      "0.856\n",
      "40 percent :\n",
      "0.878\n",
      "0.868\n",
      "0.876\n",
      "0.87\n",
      "0.86\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagenette', 10))\n",
    "print(check_simult_ldp('resnet14', 'imagenette', 10))\n",
    "print(check_simult_ldp('resnet18', 'imagenette', 10))\n",
    "print(check_simult_ldp('resnet20', 'imagenette', 10))\n",
    "print(check_simult_ldp('resnet26', 'imagenette', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagenette', 20))\n",
    "print(check_simult_ldp('resnet14', 'imagenette', 20))\n",
    "print(check_simult_ldp('resnet18', 'imagenette', 20))\n",
    "print(check_simult_ldp('resnet20', 'imagenette', 20))\n",
    "print(check_simult_ldp('resnet26', 'imagenette', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagenette', 30))\n",
    "print(check_simult_ldp('resnet14', 'imagenette', 30))\n",
    "print(check_simult_ldp('resnet18', 'imagenette', 30))\n",
    "print(check_simult_ldp('resnet20', 'imagenette', 30))\n",
    "print(check_simult_ldp('resnet26', 'imagenette', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagenette', 40))\n",
    "print(check_simult_ldp('resnet14', 'imagenette', 40))\n",
    "print(check_simult_ldp('resnet18', 'imagenette', 40))\n",
    "print(check_simult_ldp('resnet20', 'imagenette', 40))\n",
    "print(check_simult_ldp('resnet26', 'imagenette', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 percent :\n",
      "0.456\n",
      "0.464\n",
      "0.476\n",
      "0.462\n",
      "0.478\n",
      "20 percent :\n",
      "0.602\n",
      "0.58\n",
      "0.608\n",
      "0.632\n",
      "0.632\n",
      "30 percent :\n",
      "0.632\n",
      "0.64\n",
      "0.644\n",
      "0.66\n",
      "0.654\n",
      "40 percent :\n",
      "0.696\n",
      "0.68\n",
      "0.69\n",
      "0.718\n",
      "0.71\n"
     ]
    }
   ],
   "source": [
    "print('10 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagewoof', 10))\n",
    "print(check_simult_ldp('resnet14', 'imagewoof', 10))\n",
    "print(check_simult_ldp('resnet18', 'imagewoof', 10))\n",
    "print(check_simult_ldp('resnet20', 'imagewoof', 10))\n",
    "print(check_simult_ldp('resnet26', 'imagewoof', 10))\n",
    "\n",
    "print('20 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagewoof', 20))\n",
    "print(check_simult_ldp('resnet14', 'imagewoof', 20))\n",
    "print(check_simult_ldp('resnet18', 'imagewoof', 20))\n",
    "print(check_simult_ldp('resnet20', 'imagewoof', 20))\n",
    "print(check_simult_ldp('resnet26', 'imagewoof', 20))\n",
    "\n",
    "print('30 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagewoof', 30))\n",
    "print(check_simult_ldp('resnet14', 'imagewoof', 30))\n",
    "print(check_simult_ldp('resnet18', 'imagewoof', 30))\n",
    "print(check_simult_ldp('resnet20', 'imagewoof', 30))\n",
    "print(check_simult_ldp('resnet26', 'imagewoof', 30))\n",
    "\n",
    "print('40 percent :')\n",
    "print(check_simult_ldp('resnet10', 'imagewoof', 40))\n",
    "print(check_simult_ldp('resnet14', 'imagewoof', 40))\n",
    "print(check_simult_ldp('resnet18', 'imagewoof', 40))\n",
    "print(check_simult_ldp('resnet20', 'imagewoof', 40))\n",
    "print(check_simult_ldp('resnet26', 'imagewoof', 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python (pyt)",
   "language": "python",
   "name": "pyt"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
